Example usage for org.apache.http.entity.mime MultipartEntityBuilder create

List of usage examples for org.apache.http.entity.mime MultipartEntityBuilder create

  1. HOME
  2. Java
  3. org.apache.http
  4. org.apache.http.entity.mime.*
  5. MultipartEntityBuilder
  6. create

Introduction

In this page you can find the example usage for org.apache.http.entity.mime MultipartEntityBuilder create.

Prototype

public static MultipartEntityBuilder create()

Source Link

Usage

From source file:org.apache.jmeter.protocol.http.sampler.HTTPHC4Impl.java

/**
 * //www  .j a va 2  s  . c om
 * @param post {@link HttpPost}
 * @return String posted body if computable
 * @throws IOException if sending the data fails due to I/O
 */
protected String sendPostData(HttpPost post) throws IOException {
    // Buffer to hold the post body, except file content
    StringBuilder postedBody = new StringBuilder(1000);
    HTTPFileArg[] files = getHTTPFiles();

    final String contentEncoding = getContentEncodingOrNull();
    final boolean haveContentEncoding = contentEncoding != null;

    // Check if we should do a multipart/form-data or an
    // application/x-www-form-urlencoded post request
    if (getUseMultipartForPost()) {
        // If a content encoding is specified, we use that as the
        // encoding of any parameter values
        Charset charset = null;
        if (haveContentEncoding) {
            charset = Charset.forName(contentEncoding);
        } else {
            charset = MIME.DEFAULT_CHARSET;
        }

        if (log.isDebugEnabled()) {
            log.debug("Building multipart with:getDoBrowserCompatibleMultipart():"
                    + getDoBrowserCompatibleMultipart() + ", with charset:" + charset + ", haveContentEncoding:"
                    + haveContentEncoding);
        }
        // Write the request to our own stream
        MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create().setCharset(charset);
        if (getDoBrowserCompatibleMultipart()) {
            multipartEntityBuilder.setLaxMode();
        } else {
            multipartEntityBuilder.setStrictMode();
        }
        // Create the parts
        // Add any parameters
        for (JMeterProperty jMeterProperty : getArguments()) {
            HTTPArgument arg = (HTTPArgument) jMeterProperty.getObjectValue();
            String parameterName = arg.getName();
            if (arg.isSkippable(parameterName)) {
                continue;
            }
            StringBody stringBody = new StringBody(arg.getValue(), ContentType.create("text/plain", charset));
            FormBodyPart formPart = FormBodyPartBuilder.create(parameterName, stringBody).build();
            multipartEntityBuilder.addPart(formPart);
        }

        // Add any files
        // Cannot retrieve parts once added to the MultiPartEntity, so have to save them here.
        ViewableFileBody[] fileBodies = new ViewableFileBody[files.length];
        for (int i = 0; i < files.length; i++) {
            HTTPFileArg file = files[i];

            File reservedFile = FileServer.getFileServer().getResolvedFile(file.getPath());
            fileBodies[i] = new ViewableFileBody(reservedFile, file.getMimeType());
            multipartEntityBuilder.addPart(file.getParamName(), fileBodies[i]);
        }

        HttpEntity entity = multipartEntityBuilder.build();
        post.setEntity(entity);

        if (entity.isRepeatable()) {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            for (ViewableFileBody fileBody : fileBodies) {
                fileBody.hideFileData = true;
            }
            entity.writeTo(bos);
            for (ViewableFileBody fileBody : fileBodies) {
                fileBody.hideFileData = false;
            }
            bos.flush();
            // We get the posted bytes using the encoding used to create it
            postedBody.append(new String(bos.toByteArray(), contentEncoding == null ? "US-ASCII" // $NON-NLS-1$ this is the default used by HttpClient
                    : contentEncoding));
            bos.close();
        } else {
            postedBody.append("<Multipart was not repeatable, cannot view what was sent>"); // $NON-NLS-1$
        }

        //            // Set the content type TODO - needed?
        //            String multiPartContentType = multiPart.getContentType().getValue();
        //            post.setHeader(HEADER_CONTENT_TYPE, multiPartContentType);

    } else { // not multipart
        // Check if the header manager had a content type header
        // This allows the user to specify his own content-type for a POST request
        Header contentTypeHeader = post.getFirstHeader(HTTPConstants.HEADER_CONTENT_TYPE);
        boolean hasContentTypeHeader = contentTypeHeader != null && contentTypeHeader.getValue() != null
                && contentTypeHeader.getValue().length() > 0;
        // If there are no arguments, we can send a file as the body of the request
        // TODO: needs a multiple file upload scenerio
        if (!hasArguments() && getSendFileAsPostBody()) {
            // If getSendFileAsPostBody returned true, it's sure that file is not null
            HTTPFileArg file = files[0];
            if (!hasContentTypeHeader) {
                // Allow the mimetype of the file to control the content type
                if (file.getMimeType() != null && file.getMimeType().length() > 0) {
                    post.setHeader(HTTPConstants.HEADER_CONTENT_TYPE, file.getMimeType());
                } else {
                    post.setHeader(HTTPConstants.HEADER_CONTENT_TYPE,
                            HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED);
                }
            }

            FileEntity fileRequestEntity = new FileEntity(new File(file.getPath()), (ContentType) null);// TODO is null correct?
            post.setEntity(fileRequestEntity);

            // We just add placeholder text for file content
            postedBody.append("<actual file content, not shown here>");
        } else {
            // In a post request which is not multipart, we only support
            // parameters, no file upload is allowed

            // If a content encoding is specified, we set it as http parameter, so that
            // the post body will be encoded in the specified content encoding
            if (haveContentEncoding) {
                post.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, contentEncoding);
            }

            // If none of the arguments have a name specified, we
            // just send all the values as the post body
            if (getSendParameterValuesAsPostBody()) {
                // Allow the mimetype of the file to control the content type
                // This is not obvious in GUI if you are not uploading any files,
                // but just sending the content of nameless parameters
                // TODO: needs a multiple file upload scenerio
                if (!hasContentTypeHeader) {
                    HTTPFileArg file = files.length > 0 ? files[0] : null;
                    if (file != null && file.getMimeType() != null && file.getMimeType().length() > 0) {
                        post.setHeader(HTTPConstants.HEADER_CONTENT_TYPE, file.getMimeType());
                    } else {
                        // TODO - is this the correct default?
                        post.setHeader(HTTPConstants.HEADER_CONTENT_TYPE,
                                HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED);
                    }
                }

                // Just append all the parameter values, and use that as the post body
                StringBuilder postBody = new StringBuilder();
                for (JMeterProperty jMeterProperty : getArguments()) {
                    HTTPArgument arg = (HTTPArgument) jMeterProperty.getObjectValue();
                    // Note: if "Encoded?" is not selected, arg.getEncodedValue is equivalent to arg.getValue
                    if (haveContentEncoding) {
                        postBody.append(arg.getEncodedValue(contentEncoding));
                    } else {
                        postBody.append(arg.getEncodedValue());
                    }
                }
                // Let StringEntity perform the encoding
                StringEntity requestEntity = new StringEntity(postBody.toString(), contentEncoding);
                post.setEntity(requestEntity);
                postedBody.append(postBody.toString());
            } else {
                // It is a normal post request, with parameter names and values

                // Set the content type
                if (!hasContentTypeHeader) {
                    post.setHeader(HTTPConstants.HEADER_CONTENT_TYPE,
                            HTTPConstants.APPLICATION_X_WWW_FORM_URLENCODED);
                }
                // Add the parameters
                PropertyIterator args = getArguments().iterator();
                List<NameValuePair> nvps = new ArrayList<>();
                String urlContentEncoding = contentEncoding;
                if (urlContentEncoding == null || urlContentEncoding.length() == 0) {
                    // Use the default encoding for urls
                    urlContentEncoding = EncoderCache.URL_ARGUMENT_ENCODING;
                }
                while (args.hasNext()) {
                    HTTPArgument arg = (HTTPArgument) args.next().getObjectValue();
                    // The HTTPClient always urlencodes both name and value,
                    // so if the argument is already encoded, we have to decode
                    // it before adding it to the post request
                    String parameterName = arg.getName();
                    if (arg.isSkippable(parameterName)) {
                        continue;
                    }
                    String parameterValue = arg.getValue();
                    if (!arg.isAlwaysEncoded()) {
                        // The value is already encoded by the user
                        // Must decode the value now, so that when the
                        // httpclient encodes it, we end up with the same value
                        // as the user had entered.
                        parameterName = URLDecoder.decode(parameterName, urlContentEncoding);
                        parameterValue = URLDecoder.decode(parameterValue, urlContentEncoding);
                    }
                    // Add the parameter, httpclient will urlencode it
                    nvps.add(new BasicNameValuePair(parameterName, parameterValue));
                }
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(nvps, urlContentEncoding);
                post.setEntity(entity);
                if (entity.isRepeatable()) {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    post.getEntity().writeTo(bos);
                    bos.flush();
                    // We get the posted bytes using the encoding used to create it
                    if (contentEncoding != null) {
                        postedBody.append(new String(bos.toByteArray(), contentEncoding));
                    } else {
                        postedBody.append(new String(bos.toByteArray(), SampleResult.DEFAULT_HTTP_ENCODING));
                    }
                    bos.close();
                } else {
                    postedBody.append("<RequestEntity was not repeatable, cannot view what was sent>");
                }
            }
        }
    }
    return postedBody.toString();
}

From source file:org.ednovo.gooru.application.server.service.uploadServlet.java

public String fileUpload(byte[] bytes, String data, String fileName, Long fileSize, String urlVal)
        throws Exception {
    String ret = "";
    logger.info("upload Url:::" + urlVal);
    HttpClient httpClient = HttpClientBuilder.create().build();
    HttpPost httppost = new HttpPost(urlVal);
    MultipartEntityBuilder reqEntity = MultipartEntityBuilder.create();
    ByteArrayBody bab = new ByteArrayBody(bytes, fileName);
    reqEntity.addPart("image", bab);
    httppost.setEntity(reqEntity.build());
    HttpResponse response = httpClient.execute(httppost);
    HttpEntity resEntity = response.getEntity();
    if (resEntity != null) {
        ret = EntityUtils.toString(resEntity);
    }//w  w  w. j a  v  a  2s .  c  o  m
    logger.info("upload response:::" + ret);
    return ret;
}

From source file:org.flowable.app.service.editor.AppDefinitionPublishService.java

protected void deployZipArtifact(String artifactName, byte[] zipArtifact, String deploymentKey,
        String deploymentName) {//from  w  w  w  .j a v a2s  .  c o  m
    String deployApiUrl = environment.getRequiredProperty("deployment.api.url");
    String basicAuthUser = environment.getRequiredProperty("idm.admin.user");
    String basicAuthPassword = environment.getRequiredProperty("idm.admin.password");

    if (deployApiUrl.endsWith("/") == false) {
        deployApiUrl = deployApiUrl.concat("/");
    }
    deployApiUrl = deployApiUrl
            .concat(String.format("repository/deployments?deploymentKey=%s&deploymentName=%s",
                    encode(deploymentKey), encode(deploymentName)));

    HttpPost httpPost = new HttpPost(deployApiUrl);
    httpPost.setHeader(HttpHeaders.AUTHORIZATION, "Basic " + new String(
            Base64.encodeBase64((basicAuthUser + ":" + basicAuthPassword).getBytes(Charset.forName("UTF-8")))));

    MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
    entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    entityBuilder.addBinaryBody("artifact", zipArtifact, ContentType.DEFAULT_BINARY, artifactName);

    HttpEntity entity = entityBuilder.build();
    httpPost.setEntity(entity);

    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    SSLConnectionSocketFactory sslsf = null;
    try {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        sslsf = new SSLConnectionSocketFactory(builder.build(),
                SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        clientBuilder.setSSLSocketFactory(sslsf);
    } catch (Exception e) {
        logger.error("Could not configure SSL for http client", e);
        throw new InternalServerErrorException("Could not configure SSL for http client", e);
    }

    CloseableHttpClient client = clientBuilder.build();

    try {
        HttpResponse response = client.execute(httpPost);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_CREATED) {
            return;
        } else {
            logger.error("Invalid deploy result code: {}", response.getStatusLine());
            throw new InternalServerErrorException("Invalid deploy result code: " + response.getStatusLine());
        }
    } catch (IOException ioe) {
        logger.error("Error calling deploy endpoint", ioe);
        throw new InternalServerErrorException("Error calling deploy endpoint: " + ioe.getMessage());
    } finally {
        if (client != null) {
            try {
                client.close();
            } catch (IOException e) {
                logger.warn("Exception while closing http client", e);
            }
        }
    }
}

From source file:org.flowable.ui.admin.service.engine.AppDeploymentService.java

public JsonNode uploadDeployment(ServerConfig serverConfig, String name, InputStream inputStream)
        throws IOException {
    HttpPost post = new HttpPost(clientUtil.getServerUrl(serverConfig, "app-repository/deployments"));
    HttpEntity reqEntity = MultipartEntityBuilder.create()
            .addBinaryBody(name, IOUtils.toByteArray(inputStream), ContentType.APPLICATION_OCTET_STREAM, name)
            .build();//from  w w  w .  j  av a2 s .c o  m
    post.setEntity(reqEntity);
    return clientUtil.executeRequest(post, serverConfig, 201);
}

From source file:org.flowable.ui.admin.service.engine.CmmnDeploymentService.java

public JsonNode uploadDeployment(ServerConfig serverConfig, String name, InputStream inputStream)
        throws IOException {
    HttpPost post = new HttpPost(clientUtil.getServerUrl(serverConfig, "cmmn-repository/deployments"));
    HttpEntity reqEntity = MultipartEntityBuilder.create()
            .addBinaryBody(name, IOUtils.toByteArray(inputStream), ContentType.APPLICATION_OCTET_STREAM, name)
            .build();// w  ww. j av a  2  s . c  o m
    post.setEntity(reqEntity);
    return clientUtil.executeRequest(post, serverConfig, 201);
}

From source file:org.flowable.ui.admin.service.engine.DecisionTableDeploymentService.java

public JsonNode uploadDeployment(ServerConfig serverConfig, String name, InputStream inputStream)
        throws IOException {
    HttpPost post = new HttpPost(clientUtil.getServerUrl(serverConfig, "dmn-repository/deployments"));
    HttpEntity reqEntity = MultipartEntityBuilder.create()
            .addBinaryBody(name, IOUtils.toByteArray(inputStream), ContentType.APPLICATION_OCTET_STREAM, name)
            .build();/*w  w w  . java2  s .co m*/
    post.setEntity(reqEntity);
    return clientUtil.executeRequest(post, serverConfig, 201);
}

From source file:org.flowable.ui.admin.service.engine.DeploymentService.java

public JsonNode uploadDeployment(ServerConfig serverConfig, String name, InputStream inputStream)
        throws IOException {

    String deploymentKey = null;/*from   w ww.  java2 s.  c  o  m*/
    String deploymentName = null;

    byte[] inputStreamByteArray = IOUtils.toByteArray(inputStream);

    // special handling for exported bar files
    if (name != null && (name.endsWith(".zip") || name.endsWith(".bar"))) {
        JsonNode appDefinitionJson = getAppDefinitionJson(new ByteArrayInputStream(inputStreamByteArray));

        if (appDefinitionJson != null) {
            if (appDefinitionJson.has("key") && appDefinitionJson.get("key") != null) {
                deploymentKey = appDefinitionJson.get("key").asText();
            }
            if (appDefinitionJson.has("name") && appDefinitionJson.get("name") != null) {
                deploymentName = appDefinitionJson.get("name").asText();
            }
        }
    }

    URIBuilder uriBuilder = clientUtil.createUriBuilder("repository/deployments");

    if (StringUtils.isNotEmpty(deploymentKey)) {
        uriBuilder.addParameter("deploymentKey", encode(deploymentKey));
    }
    if (StringUtils.isNotEmpty(deploymentName)) {
        uriBuilder.addParameter("deploymentName", encode(deploymentName));
    }

    HttpPost post = new HttpPost(clientUtil.getServerUrl(serverConfig, uriBuilder));
    HttpEntity reqEntity = MultipartEntityBuilder.create()
            .addBinaryBody(name, inputStreamByteArray, ContentType.APPLICATION_OCTET_STREAM, name).build();
    post.setEntity(reqEntity);
    return clientUtil.executeRequest(post, serverConfig, 201);
}

From source file:org.jboss.javadoc.PostFile.java

public PostFile(final String fullUrl, final File file, final String username, final String password) {
    this.httppost = new HttpPost(fullUrl);
    this.filePath = file;
    this.mpEntityBuilder = MultipartEntityBuilder.create();
    this.username = username;
    this.password = password;

    requestBuilderPost = RequestBuilder.post();
    requestBuilderPost.setUri(fullUrl);//from w w  w .j a  v a2s.c  o  m

}

From source file:org.kaaproject.kaa.client.transport.DesktopHttpClient.java

@Override
public byte[] executeHttpRequest(String uri, LinkedHashMap<String, byte[]> entity, boolean verifyResponse)
        throws Exception { //NOSONAR
    byte[] responseDataRaw = null;
    method = new HttpPost(url + uri);
    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    for (String key : entity.keySet()) {
        builder.addBinaryBody(key, entity.get(key));
    }//from  www  . ja va 2  s. c  o  m
    HttpEntity requestEntity = builder.build();
    method.setEntity(requestEntity);
    if (!Thread.currentThread().isInterrupted()) {
        LOG.debug("Executing request {}", method.getRequestLine());
        CloseableHttpResponse response = httpClient.execute(method);
        try {
            LOG.debug("Received {}", response.getStatusLine());
            int status = response.getStatusLine().getStatusCode();
            if (status >= 200 && status < 300) {
                responseDataRaw = getResponseBody(response, verifyResponse);
            } else {
                throw new TransportException(status);
            }
        } finally {
            response.close();
            method = null;
        }
    } else {
        method = null;
        throw new InterruptedException();
    }

    return responseDataRaw;
}

From source file:org.keycloak.testsuite.oauth.ClientAuthSignedJWTTest.java

private void testUploadKeystore(String keystoreFormat, String filePath, String keyAlias, String storePassword)
        throws Exception {
    ClientRepresentation client = getClient(testRealm.getRealm(), app3.getId()).toRepresentation();
    final String certOld = client.getAttributes().get(JWTClientAuthenticator.CERTIFICATE_ATTR);

    // Load the keystore file
    URL fileUrl = (getClass().getClassLoader().getResource(filePath));
    if (fileUrl == null) {
        throw new IOException("File not found: " + filePath);
    }/*  ww w . j a  va2s . c  om*/
    File keystoreFile = new File(fileUrl.getFile());
    ContentType keystoreContentType = ContentType.create(Files.probeContentType(keystoreFile.toPath()));

    // Get admin access token, no matter it's master realm's admin
    OAuthClient.AccessTokenResponse accessTokenResponse = oauth.doGrantAccessTokenRequest(AuthRealm.MASTER,
            AuthRealm.ADMIN, AuthRealm.ADMIN, null, "admin-cli", null);
    assertEquals(200, accessTokenResponse.getStatusCode());

    final String url = suiteContext.getAuthServerInfo().getContextRoot() + "/auth/admin/realms/"
            + testRealm.getRealm() + "/clients/" + client.getId()
            + "/certificates/jwt.credential/upload-certificate";

    // Prepare the HTTP request
    FileBody fileBody = new FileBody(keystoreFile, keystoreContentType);
    HttpEntity entity = MultipartEntityBuilder.create().addPart("file", fileBody)
            .addTextBody("keystoreFormat", keystoreFormat).addTextBody("keyAlias", keyAlias)
            .addTextBody("storePassword", storePassword).addTextBody("keyPassword", "undefined").build();
    HttpPost httpRequest = new HttpPost(url);
    httpRequest.setHeader(HttpHeaders.AUTHORIZATION, "Bearer " + accessTokenResponse.getAccessToken());
    httpRequest.setEntity(entity);

    // Send the request
    HttpClient httpClient = HttpClients.createDefault();
    HttpResponse httpResponse = httpClient.execute(httpRequest);
    assertEquals(200, httpResponse.getStatusLine().getStatusCode());

    client = getClient(testRealm.getRealm(), client.getId()).toRepresentation();
    String pem;

    // Assert the uploaded certificate
    if (!keystoreFormat.equals(CERTIFICATE_PEM)) {
        InputStream keystoreIs = new FileInputStream(keystoreFile);
        KeyStore keyStore = getKeystore(keystoreIs, storePassword, keystoreFormat);
        keystoreIs.close();
        pem = KeycloakModelUtils.getPemFromCertificate((X509Certificate) keyStore.getCertificate(keyAlias));
    } else {
        pem = new String(Files.readAllBytes(keystoreFile.toPath()));
    }

    assertCertificate(client, certOld, pem);
}