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

List of usage examples for org.apache.http.entity.mime MultipartEntityBuilder 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.opentravel.schemacompiler.repository.impl.RemoteRepositoryClient.java

/**
 * @see org.opentravel.schemacompiler.repository.Repository#commit(org.opentravel.schemacompiler.repository.RepositoryItem)
 *///w w w .j ava2 s .  co m
@Override
public void commit(RepositoryItem item) throws RepositoryException {
    InputStream wipContent = null;
    try {
        validateRepositoryItem(item);

        // Obtain a file stream for the item's WIP content
        File wipFile = manager.getFileManager().getLibraryWIPContentLocation(item.getBaseNamespace(),
                item.getFilename());

        if (!wipFile.exists()) {
            throw new RepositoryException("The work-in-process file does not exist: " + item.getFilename());
        }
        wipContent = new FileInputStream(wipFile);

        // Build the HTTP request for the remote service
        RepositoryItemIdentityType itemIdentity = createItemIdentity(item);
        Marshaller marshaller = RepositoryFileManager.getSharedJaxbContext().createMarshaller();
        HttpPost request = newPostRequest(COMMIT_ENDPOINT);
        MultipartEntityBuilder mpEntity = MultipartEntityBuilder.create();
        StringWriter xmlWriter = new StringWriter();

        marshaller.marshal(objectFactory.createRepositoryItemIdentity(itemIdentity), xmlWriter);
        mpEntity.addTextBody("item", xmlWriter.toString(), ContentType.TEXT_XML);
        mpEntity.addBinaryBody("fileContent", toByteArray(wipContent), ContentType.DEFAULT_BINARY,
                item.getFilename());

        // mpEntity.addPart( "fileContent", new InputStreamBody(wipContent, item.getFilename())
        // );

        request.setEntity(mpEntity.build());

        // Send the web service request and check the response
        log.info("Sending commit request to HTTP endpoint: " + endpointUrl);
        HttpResponse response = executeWithAuthentication(request);

        if (response.getStatusLine().getStatusCode() != HTTP_RESPONSE_STATUS_OK) {
            throw new RepositoryException(getResponseErrorMessage(response));
        }
        log.info("Commit response received - Status OK");

        // Update the local cache with the content we just sent to the remote web service
        downloadContent(item, true);

    } catch (JAXBException e) {
        throw new RepositoryException("The format of the library meta-data is unreadable.", e);

    } catch (IOException e) {
        throw new RepositoryException("The remote repository is unavailable.", e);

    } finally {
        try {
            if (wipContent != null)
                wipContent.close();
        } catch (Throwable t) {
        }
    }
}

From source file:com.smartsheet.api.internal.AbstractResources.java

/**
 * Create a multipart upload request./* w ww  .j  a v  a  2 s.  c  om*/
 *
 * @param url the url
 * @param t the object to create
 * @param partName the name of the part
 * @param inputstream the file inputstream
 * @param contentType the type of the file to be attached
 * @return the http request
 * @throws UnsupportedEncodingException the unsupported encoding exception
 */
public <T> Attachment attachFile(String url, T t, String partName, InputStream inputstream, String contentType,
        String attachmentName) throws SmartsheetException {
    Util.throwIfNull(inputstream, contentType);
    Attachment attachment = null;
    final String boundary = "----" + System.currentTimeMillis();

    CloseableHttpClient httpClient = HttpClients.createDefault();
    HttpPost uploadFile = createHttpPost(this.getSmartsheet().getBaseURI().resolve(url));

    try {
        uploadFile.setHeader("Content-Type", "multipart/form-data; boundary=" + boundary);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.setBoundary(boundary);
    builder.addTextBody(partName, this.getSmartsheet().getJsonSerializer().serialize(t),
            ContentType.APPLICATION_JSON);
    builder.addBinaryBody("file", inputstream, ContentType.create(contentType), attachmentName);
    org.apache.http.HttpEntity multipart = builder.build();

    uploadFile.setEntity(multipart);

    try {
        CloseableHttpResponse response = httpClient.execute(uploadFile);
        org.apache.http.HttpEntity responseEntity = response.getEntity();
        attachment = this.getSmartsheet().getJsonSerializer()
                .deserializeResult(Attachment.class, responseEntity.getContent()).getResult();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return attachment;
}

From source file:com.lehman.ic9.net.httpClient.java

/**
 * Sets request information for the type of POST request. This is determined 
 * by the post type provided./*ww  w .  j  ava2 s .c o m*/
 * @param postTypeStr is a String with the postType.
 * @param Obj is a Javascript object to set for the request.
 * @param ContentType is a String with the content-type for the custom request.
 * @throws ic9exception Exception
 * @throws UnsupportedEncodingException Exception
 */
@SuppressWarnings("unchecked")
private void setPostInfo(String postTypeStr, Object Obj, String ContentType)
        throws ic9exception, UnsupportedEncodingException {
    postType pt = this.getPostType(postTypeStr);
    if (pt == postType.URL_ENCODED) {
        Map<String, Object> jobj = (Map<String, Object>) Obj;
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        for (String key : jobj.keySet()) {
            Object val = jobj.get(key);
            nvps.add(new BasicNameValuePair(key, val.toString()));
        }
        this.respEnt = new UrlEncodedFormEntity(nvps);
    } else if (pt == postType.MULTIPART) {
        MultipartEntityBuilder mpEntBuilder = MultipartEntityBuilder.create();
        Map<String, Object> jobj = (Map<String, Object>) Obj;
        for (String key : jobj.keySet()) {
            Map<String, Object> part = (Map<String, Object>) jobj.get(key);
            if (part.containsKey("name") && part.containsKey("data")) {
                String pkey = (String) part.get("name");
                if (part.get("data") instanceof byte[]) {
                    byte[] data = (byte[]) part.get("data");
                    mpEntBuilder.addPart(key, new ByteArrayBody(data, pkey));
                } else if (part.get("data") instanceof String) {
                    String data = (String) part.get("data");
                    mpEntBuilder.addPart(key,
                            new StringBody(data, org.apache.http.entity.ContentType.DEFAULT_TEXT));
                }
            } else
                throw new ic9exception(
                        "httpClient.setPotInfo(): Multipart from data expects and object of httpPart objects.");
        }
        this.respEnt = mpEntBuilder.build();
    } else {
        if (Obj instanceof String) {
            StringEntity se = new StringEntity((String) Obj);
            if (ContentType != null)
                se.setContentType(ContentType);
            else
                throw new ic9exception(
                        "httpClient.setPostInfo(): For custom postType, the third argument for content-type must be set.");
            this.respEnt = se;
        } else if (Obj instanceof Map) {
            Map<String, Object> tobj = (Map<String, Object>) Obj;

            if (tobj.containsKey("data") && tobj.get("data") instanceof byte[]) {
                if (ContentType != null) {
                    ByteArrayEntity bae = new ByteArrayEntity((byte[]) Obj);
                    bae.setContentType(ContentType);
                    this.respEnt = bae;
                } else
                    throw new ic9exception(
                            "httpClient.setPostInfo(): For custom postType, the third argument for content-type must be set.");
            } else
                throw new ic9exception(
                        "httpClient.setPostInfo(): Provided object is not of type Buffer or is missing 'data' attribute. (data should be byte[])");
        } else
            throw new ic9exception(
                    "httpClient.setPostInfo(): Second argument to POST call expecting String or Buffer object.");
    }
}

From source file:io.swagger.client.api.CameraApi.java

/**
* Camera status/* w w  w.  j  a va  2  s  .c  o m*/
* Return the camera status 
 * @return CameraStatus
*/
public CameraStatus statusGet()
        throws TimeoutException, ExecutionException, InterruptedException, ApiException {
    Object postBody = null;

    // create path and map variables
    String path = "/status".replaceAll("\\{format\\}", "json");

    // query params
    List<Pair> queryParams = new ArrayList<Pair>();
    // header params
    Map<String, String> headerParams = new HashMap<String, String>();
    // form params
    Map<String, String> formParams = new HashMap<String, String>();

    String[] contentTypes = {

    };
    String contentType = contentTypes.length > 0 ? contentTypes[0] : "application/json";

    if (contentType.startsWith("multipart/form-data")) {
        // file uploading
        MultipartEntityBuilder localVarBuilder = MultipartEntityBuilder.create();

        HttpEntity httpEntity = localVarBuilder.build();
        postBody = httpEntity;
    } else {
        // normal form params
    }

    String[] authNames = new String[] {};

    try {
        String localVarResponse = apiInvoker.invokeAPI(basePath, path, "GET", queryParams, postBody,
                headerParams, formParams, contentType, authNames);
        if (localVarResponse != null) {
            return (CameraStatus) ApiInvoker.deserialize(localVarResponse, "", CameraStatus.class);
        } else {
            return null;
        }
    } catch (ApiException ex) {
        throw ex;
    } catch (InterruptedException ex) {
        throw ex;
    } catch (ExecutionException ex) {
        if (ex.getCause() instanceof VolleyError) {
            VolleyError volleyError = (VolleyError) ex.getCause();
            if (volleyError.networkResponse != null) {
                throw new ApiException(volleyError.networkResponse.statusCode, volleyError.getMessage());
            }
        }
        throw ex;
    } catch (TimeoutException ex) {
        throw ex;
    }
}

From source file:org.wso2.msf4j.HttpServerTest.java

@Test
public void tesFormParamWithCollection() throws IOException {
    // Send x-form-url-encoded request
    HttpURLConnection connection = request("/test/v1/formParamWithList", HttpMethod.POST);
    String rawData = "names=WSO2&names=IBM";
    ByteBuffer encodedData = Charset.defaultCharset().encode(rawData);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_FORM_URLENCODED);
    connection.setRequestProperty("Content-Length", String.valueOf(encodedData.array().length));
    try (OutputStream os = connection.getOutputStream()) {
        os.write(Arrays.copyOf(encodedData.array(), encodedData.limit()));
    }//  ww  w .  j  ava 2 s.  co m

    InputStream inputStream = connection.getInputStream();
    String response = StreamUtil.asString(inputStream);
    IOUtils.closeQuietly(inputStream);
    connection.disconnect();
    assertEquals(response, "2");

    // Send multipart/form-data request
    connection = request("/test/v1/formParamWithList", HttpMethod.POST);
    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.addPart("names", new StringBody("WSO2", ContentType.TEXT_PLAIN));
    builder.addPart("names", new StringBody("IBM", ContentType.TEXT_PLAIN));
    builder.addPart("names", new StringBody("Oracle", ContentType.TEXT_PLAIN));
    HttpEntity build = builder.build();
    connection.setRequestProperty("Content-Type", build.getContentType().getValue());
    try (OutputStream out = connection.getOutputStream()) {
        build.writeTo(out);
    }

    inputStream = connection.getInputStream();
    response = StreamUtil.asString(inputStream);
    IOUtils.closeQuietly(inputStream);
    connection.disconnect();
    assertEquals(response, "3");

    // Send x-form-url-encoded request
    connection = request("/test/v1/formParamWithSet", HttpMethod.POST);
    rawData = "names=WSO2&names=IBM&names=IBM";
    encodedData = Charset.defaultCharset().encode(rawData);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_FORM_URLENCODED);
    connection.setRequestProperty("Content-Length", String.valueOf(encodedData.array().length));
    try (OutputStream os = connection.getOutputStream()) {
        os.write(Arrays.copyOf(encodedData.array(), encodedData.limit()));
    }

    inputStream = connection.getInputStream();
    response = StreamUtil.asString(inputStream);
    IOUtils.closeQuietly(inputStream);
    connection.disconnect();
    assertEquals(response, "2");

    // Send multipart/form-data request
    connection = request("/test/v1/formParamWithSet", HttpMethod.POST);
    builder = MultipartEntityBuilder.create();
    builder.addPart("names", new StringBody("WSO2", ContentType.TEXT_PLAIN));
    builder.addPart("names", new StringBody("IBM", ContentType.TEXT_PLAIN));
    builder.addPart("names", new StringBody("IBM", ContentType.TEXT_PLAIN));
    builder.addPart("names", new StringBody("Oracle", ContentType.TEXT_PLAIN));
    build = builder.build();
    connection.setRequestProperty("Content-Type", build.getContentType().getValue());
    try (OutputStream out = connection.getOutputStream()) {
        build.writeTo(out);
    }

    inputStream = connection.getInputStream();
    response = StreamUtil.asString(inputStream);
    IOUtils.closeQuietly(inputStream);
    connection.disconnect();
    assertEquals(response, "3");
}

From source file:org.openbaton.marketplace.core.VNFPackageManagement.java

public void dispatch3(VNFPackageMetadata packageMetadata) throws IOException, ArchiveException, SDKException {
    log.debug("Trying to upload package to FITEagle");

    String url = "http://" + fitEagleIp + ":" + fitEaglePort + "/OpenBaton/upload/v2";

    log.debug("FITEagle URL is: " + url);

    //    HttpClient client = HttpClientBuilder.create().build();
    HttpClient client = HttpClients.createDefault();
    HttpPost request = new HttpPost(url);

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();

    byte[] vnfPackageFile = packageMetadata.getVnfPackageFile();
    log.debug("Trying to add binary file of length: " + vnfPackageFile.length);
    builder.addBinaryBody("file", vnfPackageFile, ContentType.APPLICATION_OCTET_STREAM,
            packageMetadata.getName());// ww w  . j  a  v a 2  s. com

    String currentUser = userManagement.getCurrentUser();
    request.addHeader("username", currentUser);
    log.debug("Added username header: " + currentUser);

    request.setEntity(builder.build());
    log.debug("Added binary file of length: " + vnfPackageFile.length);
    HttpResponse response = client.execute(request);
    log.debug("Executed POST!");
    log.debug("Response Code from FITEAGLE: " + response.getStatusLine().getStatusCode());
}

From source file:gov.osti.services.Metadata.java

/**
 * Send this Metadata to the ARCHIVER external support process.
 *
 * Needs a CODE ID and one of either an ARCHIVE FILE or REPOSITORY LINK.
 *
 * If nothing supplied to archive, do nothing.
 *
 * @param codeId the CODE ID for this METADATA
 * @param repositoryLink (optional) the REPOSITORY LINK value, or null if none
 * @param archiveFile (optional) the File recently uploaded to ARCHIVE, or null if none
 * @param archiveContainer (optional) the Container recently uploaded to ARCHIVE, or null if none
 * @throws IOException on IO transmission errors
 *///  w  w w  .jav a  2  s.c  o  m
private static void sendToArchiver(Long codeId, String repositoryLink, File archiveFile, File archiveContainer)
        throws IOException {
    if ("".equals(ARCHIVER_URL))
        return;

    // Nothing sent?
    if (StringUtils.isBlank(repositoryLink) && null == archiveFile && null == archiveContainer)
        return;

    // set up a connection
    CloseableHttpClient hc = HttpClientBuilder.create().setDefaultRequestConfig(RequestConfig.custom()
            .setSocketTimeout(300000).setConnectTimeout(300000).setConnectionRequestTimeout(300000).build())
            .build();

    try {
        HttpPost post = new HttpPost(ARCHIVER_URL);
        // attributes to send
        ObjectNode request = mapper.createObjectNode();
        request.put("code_id", codeId);
        request.put("repository_link", repositoryLink);

        // determine if there's a file to send or not
        if (null == archiveFile && null == archiveContainer) {
            post.setHeader("Content-Type", "application/json");
            post.setHeader("Accept", "application/json");

            post.setEntity(new StringEntity(request.toString(), "UTF-8"));
        } else {
            MultipartEntityBuilder mpe = MultipartEntityBuilder.create()
                    .setMode(HttpMultipartMode.BROWSER_COMPATIBLE)
                    .addPart("project", new StringBody(request.toString(), ContentType.APPLICATION_JSON));

            if (archiveFile != null)
                mpe.addPart("file", new FileBody(archiveFile, ContentType.DEFAULT_BINARY));

            if (archiveContainer != null)
                mpe.addPart("container", new FileBody(archiveContainer, ContentType.DEFAULT_BINARY));

            post.setEntity(mpe.build());
        }
        HttpResponse response = hc.execute(post);

        int statusCode = response.getStatusLine().getStatusCode();

        if (HttpStatus.SC_OK != statusCode && HttpStatus.SC_CREATED != statusCode) {
            throw new IOException("Archiver Error: " + EntityUtils.toString(response.getEntity()));
        }
    } catch (IOException e) {
        log.warn("Archiver request error: " + e.getMessage());
        throw e;
    } finally {
        try {
            if (null != hc)
                hc.close();
        } catch (IOException e) {
            log.warn("Close Error: " + e.getMessage());
        }
    }
}

From source file:io.swagger.client.api.CameraApi.java

/**
* Camera status/*from w  w  w  .  j  a  v  a  2 s  . com*/
* Return the camera status 
        
*/
public void statusGet(final Response.Listener<CameraStatus> responseListener,
        final Response.ErrorListener errorListener) {
    Object postBody = null;

    // create path and map variables
    String path = "/status".replaceAll("\\{format\\}", "json");

    // query params
    List<Pair> queryParams = new ArrayList<Pair>();
    // header params
    Map<String, String> headerParams = new HashMap<String, String>();
    // form params
    Map<String, String> formParams = new HashMap<String, String>();

    String[] contentTypes = {

    };
    String contentType = contentTypes.length > 0 ? contentTypes[0] : "application/json";

    if (contentType.startsWith("multipart/form-data")) {
        // file uploading
        MultipartEntityBuilder localVarBuilder = MultipartEntityBuilder.create();

        HttpEntity httpEntity = localVarBuilder.build();
        postBody = httpEntity;
    } else {
        // normal form params
    }

    String[] authNames = new String[] {};

    try {
        apiInvoker.invokeAPI(basePath, path, "GET", queryParams, postBody, headerParams, formParams,
                contentType, authNames, new Response.Listener<String>() {
                    @Override
                    public void onResponse(String localVarResponse) {
                        try {
                            responseListener.onResponse((CameraStatus) ApiInvoker.deserialize(localVarResponse,
                                    "", CameraStatus.class));
                        } catch (ApiException exception) {
                            errorListener.onErrorResponse(new VolleyError(exception));
                        }
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        errorListener.onErrorResponse(error);
                    }
                });
    } catch (ApiException ex) {
        errorListener.onErrorResponse(new VolleyError(ex));
    }
}

From source file:lucee.runtime.tag.Http.java

private void _doEndTag() throws PageException, IOException {

    long start = System.nanoTime();
    HttpClientBuilder builder = HTTPEngine4Impl.getHttpClientBuilder();
    ssl(builder);/*www .  ja v  a 2s.  com*/

    // redirect
    if (redirect)
        builder.setRedirectStrategy(new DefaultRedirectStrategy());
    else
        builder.disableRedirectHandling();

    // cookies
    BasicCookieStore cookieStore = new BasicCookieStore();
    builder.setDefaultCookieStore(cookieStore);

    ConfigWeb cw = pageContext.getConfig();
    HttpRequestBase req = null;
    HttpContext httpContext = null;

    CacheHandler cacheHandler = null;
    String cacheId = null;

    // HttpRequestBase req = init(pageContext.getConfig(),this,client,params,url,port);
    {
        if (StringUtil.isEmpty(charset, true))
            charset = ((PageContextImpl) pageContext).getWebCharset().name();
        else
            charset = charset.trim();

        // check if has fileUploads
        boolean doUploadFile = false;
        for (int i = 0; i < this.params.size(); i++) {
            if ((this.params.get(i)).getType() == HttpParamBean.TYPE_FILE) {
                doUploadFile = true;
                break;
            }
        }

        // parse url (also query string)
        int len = this.params.size();
        StringBuilder sbQS = new StringBuilder();
        for (int i = 0; i < len; i++) {
            HttpParamBean param = this.params.get(i);
            int type = param.getType();
            // URL
            if (type == HttpParamBean.TYPE_URL) {
                if (sbQS.length() > 0)
                    sbQS.append('&');
                sbQS.append(param.getEncoded() ? urlenc(param.getName(), charset) : param.getName());
                sbQS.append('=');
                sbQS.append(param.getEncoded() ? urlenc(param.getValueAsString(), charset)
                        : param.getValueAsString());
            }
        }

        String host = null;
        HttpHost httpHost;
        try {
            URL _url = HTTPUtil.toURL(url, port, encoded);
            httpHost = new HttpHost(_url.getHost(), _url.getPort());
            host = _url.getHost();
            url = _url.toExternalForm();
            if (sbQS.length() > 0) {
                // no existing QS
                if (StringUtil.isEmpty(_url.getQuery())) {
                    url += "?" + sbQS;
                } else {
                    url += "&" + sbQS;
                }
            }
        } catch (MalformedURLException mue) {
            throw Caster.toPageException(mue);
        }

        // cache
        if (cachedWithin != null) {

            cacheId = createCacheId();

            cacheHandler = pageContext.getConfig().getCacheHandlerCollection(Config.CACHE_TYPE_HTTP, null)
                    .getInstanceMatchingObject(cachedWithin, null);

            if (cacheHandler instanceof CacheHandlerPro) {

                CacheItem cacheItem = ((CacheHandlerPro) cacheHandler).get(pageContext, cacheId, cachedWithin);

                if (cacheItem instanceof HTTPCacheItem) {
                    pageContext.setVariable(result, ((HTTPCacheItem) cacheItem).getData());
                    return;
                }
            } else if (cacheHandler != null) { // TODO this else block can be removed when all cache handlers implement CacheHandlerPro

                CacheItem cacheItem = cacheHandler.get(pageContext, cacheId);

                if (cacheItem instanceof HTTPCacheItem) {
                    pageContext.setVariable(result, ((HTTPCacheItem) cacheItem).getData());
                    return;
                }
            }
        }

        // cache not found, process and cache result if needed

        // select best matching method (get,post, post multpart (file))

        boolean isBinary = false;
        boolean doMultiPart = doUploadFile || this.multiPart;

        HttpEntityEnclosingRequest eeReqPost = null;
        HttpEntityEnclosingRequest eeReq = null;

        if (this.method == METHOD_GET) {
            req = new HttpGetWithBody(url);
            eeReq = (HttpEntityEnclosingRequest) req;
        } else if (this.method == METHOD_HEAD) {
            req = new HttpHead(url);
        } else if (this.method == METHOD_DELETE) {
            isBinary = true;
            req = new HttpDeleteWithBody(url);
            eeReq = (HttpEntityEnclosingRequest) req;
        } else if (this.method == METHOD_PUT) {
            isBinary = true;
            HttpPut put = new HttpPut(url);
            eeReqPost = put;
            req = put;
            eeReq = put;
        } else if (this.method == METHOD_TRACE) {
            isBinary = true;
            req = new HttpTrace(url);
        } else if (this.method == METHOD_OPTIONS) {
            isBinary = true;
            req = new HttpOptions(url);
        } else if (this.method == METHOD_PATCH) {
            isBinary = true;
            eeReq = HTTPPatchFactory.getHTTPPatch(url);
            req = (HttpRequestBase) eeReq;
        } else {
            isBinary = true;
            eeReqPost = new HttpPost(url);
            req = (HttpPost) eeReqPost;
            eeReq = eeReqPost;
        }

        boolean hasForm = false;
        boolean hasBody = false;
        boolean hasContentType = false;
        // Set http params
        ArrayList<FormBodyPart> parts = new ArrayList<FormBodyPart>();

        StringBuilder acceptEncoding = new StringBuilder();
        java.util.List<NameValuePair> postParam = eeReqPost != null ? new ArrayList<NameValuePair>() : null;

        for (int i = 0; i < len; i++) {
            HttpParamBean param = this.params.get(i);
            int type = param.getType();

            // URL
            if (type == HttpParamBean.TYPE_URL) {
                // listQS.add(new BasicNameValuePair(translateEncoding(param.getName(), http.charset),translateEncoding(param.getValueAsString(),
                // http.charset)));
            }
            // Form
            else if (type == HttpParamBean.TYPE_FORM) {
                hasForm = true;
                if (this.method == METHOD_GET)
                    throw new ApplicationException(
                            "httpparam with type formfield can only be used when the method attribute of the parent http tag is set to post");
                if (eeReqPost != null) {
                    if (doMultiPart) {
                        parts.add(new FormBodyPart(param.getName(),
                                new StringBody(param.getValueAsString(), CharsetUtil.toCharset(charset))));
                    } else {
                        postParam.add(new BasicNameValuePair(param.getName(), param.getValueAsString()));
                    }
                }
                // else if(multi!=null)multi.addParameter(param.getName(),param.getValueAsString());
            }
            // CGI
            else if (type == HttpParamBean.TYPE_CGI) {
                if (param.getEncoded())
                    req.addHeader(urlenc(param.getName(), charset), urlenc(param.getValueAsString(), charset));
                else
                    req.addHeader(param.getName(), param.getValueAsString());
            }
            // Header
            else if (type == HttpParamBean.TYPE_HEADER) {
                if (param.getName().equalsIgnoreCase("content-type"))
                    hasContentType = true;

                if (param.getName().equalsIgnoreCase("Content-Length")) {
                } else if (param.getName().equalsIgnoreCase("Accept-Encoding")) {
                    acceptEncoding.append(headerValue(param.getValueAsString()));
                    acceptEncoding.append(", ");
                } else
                    req.addHeader(param.getName(), headerValue(param.getValueAsString()));
            }
            // Cookie
            else if (type == HttpParamBean.TYPE_COOKIE) {
                HTTPEngine4Impl.addCookie(cookieStore, host, param.getName(), param.getValueAsString(), "/",
                        charset);
            }
            // File
            else if (type == HttpParamBean.TYPE_FILE) {
                hasForm = true;
                if (this.method == METHOD_GET)
                    throw new ApplicationException(
                            "httpparam type file can't only be used, when method of the tag http equal post");
                // if(param.getFile()==null) throw new ApplicationException("httpparam type file can't only be used, when method of the tag http equal
                // post");
                String strCT = getContentType(param);
                ContentType ct = HTTPUtil.toContentType(strCT, null);

                String mt = "text/xml";
                if (ct != null && !StringUtil.isEmpty(ct.getMimeType(), true))
                    mt = ct.getMimeType();

                String cs = charset;
                if (ct != null && !StringUtil.isEmpty(ct.getCharset(), true))
                    cs = ct.getCharset();

                if (doMultiPart) {
                    try {
                        Resource res = param.getFile();
                        parts.add(new FormBodyPart(param.getName(),
                                new ResourceBody(res, mt, res.getName(), cs)));
                        // parts.add(new ResourcePart(param.getName(),new ResourcePartSource(param.getFile()),getContentType(param),_charset));
                    } catch (FileNotFoundException e) {
                        throw new ApplicationException("can't upload file, path is invalid", e.getMessage());
                    }
                }
            }
            // XML
            else if (type == HttpParamBean.TYPE_XML) {
                ContentType ct = HTTPUtil.toContentType(param.getMimeType(), null);

                String mt = "text/xml";
                if (ct != null && !StringUtil.isEmpty(ct.getMimeType(), true))
                    mt = ct.getMimeType();

                String cs = charset;
                if (ct != null && !StringUtil.isEmpty(ct.getCharset(), true))
                    cs = ct.getCharset();

                hasBody = true;
                hasContentType = true;
                req.addHeader("Content-type", mt + "; charset=" + cs);
                if (eeReq == null)
                    throw new ApplicationException(
                            "type xml is only supported for methods get, delete, post, and put");
                HTTPEngine4Impl.setBody(eeReq, param.getValueAsString(), mt, cs);
            }
            // Body
            else if (type == HttpParamBean.TYPE_BODY) {
                ContentType ct = HTTPUtil.toContentType(param.getMimeType(), null);

                String mt = null;
                if (ct != null && !StringUtil.isEmpty(ct.getMimeType(), true))
                    mt = ct.getMimeType();

                String cs = charset;
                if (ct != null && !StringUtil.isEmpty(ct.getCharset(), true))
                    cs = ct.getCharset();

                hasBody = true;
                if (eeReq == null)
                    throw new ApplicationException(
                            "type body is only supported for methods get, delete, post, and put");
                HTTPEngine4Impl.setBody(eeReq, param.getValue(), mt, cs);

            } else {
                throw new ApplicationException("invalid type [" + type + "]");
            }

        }

        // post params
        if (postParam != null && postParam.size() > 0)
            eeReqPost.setEntity(new org.apache.http.client.entity.UrlEncodedFormEntity(postParam, charset));

        if (compression) {
            acceptEncoding.append("gzip");
        } else {
            acceptEncoding.append("deflate;q=0");
            req.setHeader("TE", "deflate;q=0");
        }
        req.setHeader("Accept-Encoding", acceptEncoding.toString());

        // multipart
        if (doMultiPart && eeReq != null) {
            hasContentType = true;
            boolean doIt = true;
            if (!this.multiPart && parts.size() == 1) {
                ContentBody body = parts.get(0).getBody();
                if (body instanceof StringBody) {
                    StringBody sb = (StringBody) body;
                    try {
                        org.apache.http.entity.ContentType ct = org.apache.http.entity.ContentType
                                .create(sb.getMimeType(), sb.getCharset());
                        String str = IOUtil.toString(sb.getReader());
                        StringEntity entity = new StringEntity(str, ct);
                        eeReq.setEntity(entity);

                    } catch (IOException e) {
                        throw Caster.toPageException(e);
                    }
                    doIt = false;
                }
            }

            if (doIt) {

                MultipartEntityBuilder mpeBuilder = MultipartEntityBuilder.create().setStrictMode();

                // enabling the line below will append charset=... to the Content-Type header
                // if (!StringUtil.isEmpty(charset, true))
                // mpeBuilder.setCharset(CharsetUtil.toCharset(charset));

                Iterator<FormBodyPart> it = parts.iterator();
                while (it.hasNext()) {
                    FormBodyPart part = it.next();
                    mpeBuilder.addPart(part);
                }

                eeReq.setEntity(mpeBuilder.build());
            }
            // eem.setRequestEntity(new MultipartRequestEntityFlex(parts.toArray(new Part[parts.size()]), eem.getParams(),http.multiPartType));
        }

        if (hasBody && hasForm)
            throw new ApplicationException("mixing httpparam  type file/formfield and body/XML is not allowed");

        if (!hasContentType) {
            if (isBinary) {
                if (hasBody)
                    req.addHeader("Content-type", "application/octet-stream");
                else
                    req.addHeader("Content-type", "application/x-www-form-urlencoded; charset=" + charset);
            } else {
                if (hasBody)
                    req.addHeader("Content-type", "text/html; charset=" + charset);
            }
        }

        // set User Agent
        if (!hasHeaderIgnoreCase(req, "User-Agent"))
            req.setHeader("User-Agent", this.useragent);

        // set timeout
        setTimeout(builder, checkRemainingTimeout());

        // set Username and Password
        if (this.username != null) {
            if (this.password == null)
                this.password = "";
            if (AUTH_TYPE_NTLM == this.authType) {
                if (StringUtil.isEmpty(this.workStation, true))
                    throw new ApplicationException(
                            "attribute workstation is required when authentication type is [NTLM]");
                if (StringUtil.isEmpty(this.domain, true))
                    throw new ApplicationException(
                            "attribute domain is required when authentication type is [NTLM]");

                HTTPEngine4Impl.setNTCredentials(builder, this.username, this.password, this.workStation,
                        this.domain);
            } else
                httpContext = HTTPEngine4Impl.setCredentials(builder, httpHost, this.username, this.password,
                        preauth);
        }

        // set Proxy
        ProxyData proxy = null;
        if (!StringUtil.isEmpty(this.proxyserver)) {
            proxy = ProxyDataImpl.getInstance(this.proxyserver, this.proxyport, this.proxyuser,
                    this.proxypassword);
        }
        if (pageContext.getConfig().isProxyEnableFor(host)) {
            proxy = pageContext.getConfig().getProxyData();
        }
        HTTPEngine4Impl.setProxy(builder, req, proxy);

    }

    CloseableHttpClient client = null;
    try {
        if (httpContext == null)
            httpContext = new BasicHttpContext();

        Struct cfhttp = new StructImpl();
        cfhttp.setEL(ERROR_DETAIL, "");
        pageContext.setVariable(result, cfhttp);

        /////////////////////////////////////////// EXECUTE /////////////////////////////////////////////////
        client = builder.build();
        Executor4 e = new Executor4(pageContext, this, client, httpContext, req, redirect);
        HTTPResponse4Impl rsp = null;

        if (timeout == null || timeout.getMillis() <= 0) {
            try {
                rsp = e.execute(httpContext);
            }

            catch (Throwable t) {
                ExceptionUtil.rethrowIfNecessary(t);
                if (!throwonerror) {
                    if (t instanceof SocketTimeoutException)
                        setRequestTimeout(cfhttp);
                    else
                        setUnknownHost(cfhttp, t);
                    return;
                }
                throw toPageException(t, rsp);

            }
        } else {
            e.start();
            try {
                synchronized (this) {// print.err(timeout);
                    this.wait(timeout.getMillis());
                }
            } catch (InterruptedException ie) {
                throw Caster.toPageException(ie);
            }
            if (e.t != null) {
                if (!throwonerror) {
                    setUnknownHost(cfhttp, e.t);
                    return;
                }
                throw toPageException(e.t, rsp);
            }

            rsp = e.response;

            if (!e.done) {
                req.abort();
                if (throwonerror)
                    throw new HTTPException("408 Request Time-out", "a timeout occurred in tag http", 408,
                            "Time-out", rsp == null ? null : rsp.getURL());
                setRequestTimeout(cfhttp);
                return;
                // throw new ApplicationException("timeout");
            }
        }

        /////////////////////////////////////////// EXECUTE /////////////////////////////////////////////////
        Charset responseCharset = CharsetUtil.toCharset(rsp.getCharset());
        int statCode = 0;
        // Write Response Scope
        // String rawHeader=httpMethod.getStatusLine().toString();
        String mimetype = null;
        String contentEncoding = null;

        // status code
        cfhttp.set(STATUSCODE, ((rsp.getStatusCode() + " " + rsp.getStatusText()).trim()));
        cfhttp.set(STATUS_CODE, new Double(statCode = rsp.getStatusCode()));
        cfhttp.set(STATUS_TEXT, (rsp.getStatusText()));
        cfhttp.set(HTTP_VERSION, (rsp.getProtocolVersion()));

        // responseHeader
        lucee.commons.net.http.Header[] headers = rsp.getAllHeaders();
        StringBuffer raw = new StringBuffer(rsp.getStatusLine() + " ");
        Struct responseHeader = new StructImpl();
        Struct cookie;
        Array setCookie = new ArrayImpl();
        Query cookies = new QueryImpl(
                new String[] { "name", "value", "path", "domain", "expires", "secure", "httpOnly" }, 0,
                "cookies");

        for (int i = 0; i < headers.length; i++) {
            lucee.commons.net.http.Header header = headers[i];
            // print.ln(header);

            raw.append(header.toString() + " ");
            if (header.getName().equalsIgnoreCase("Set-Cookie")) {
                setCookie.append(header.getValue());
                parseCookie(cookies, header.getValue());
            } else {
                // print.ln(header.getName()+"-"+header.getValue());
                Object value = responseHeader.get(KeyImpl.getInstance(header.getName()), null);
                if (value == null)
                    responseHeader.set(KeyImpl.getInstance(header.getName()), header.getValue());
                else {
                    Array arr = null;
                    if (value instanceof Array) {
                        arr = (Array) value;
                    } else {
                        arr = new ArrayImpl();
                        responseHeader.set(KeyImpl.getInstance(header.getName()), arr);
                        arr.appendEL(value);
                    }
                    arr.appendEL(header.getValue());
                }
            }

            // Content-Type
            if (header.getName().equalsIgnoreCase("Content-Type")) {
                mimetype = header.getValue();
                if (mimetype == null)
                    mimetype = NO_MIMETYPE;
            }

            // Content-Encoding
            if (header.getName().equalsIgnoreCase("Content-Encoding")) {
                contentEncoding = header.getValue();
            }

        }
        cfhttp.set(RESPONSEHEADER, responseHeader);
        cfhttp.set(KeyConstants._cookies, cookies);
        responseHeader.set(STATUS_CODE, new Double(statCode = rsp.getStatusCode()));
        responseHeader.set(EXPLANATION, (rsp.getStatusText()));
        if (setCookie.size() > 0)
            responseHeader.set(SET_COOKIE, setCookie);

        // is text
        boolean isText = mimetype == null || mimetype == NO_MIMETYPE || HTTPUtil.isTextMimeType(mimetype);

        // is multipart
        boolean isMultipart = MultiPartResponseUtils.isMultipart(mimetype);

        cfhttp.set(KeyConstants._text, Caster.toBoolean(isText));

        // mimetype charset
        // boolean responseProvideCharset=false;
        if (!StringUtil.isEmpty(mimetype, true)) {
            if (isText) {
                String[] types = HTTPUtil.splitMimeTypeAndCharset(mimetype, null);
                if (types[0] != null)
                    cfhttp.set(KeyConstants._mimetype, types[0]);
                if (types[1] != null)
                    cfhttp.set(CHARSET, types[1]);

            } else
                cfhttp.set(KeyConstants._mimetype, mimetype);
        } else
            cfhttp.set(KeyConstants._mimetype, NO_MIMETYPE);

        // File
        Resource file = null;

        if (strFile != null && strPath != null) {
            file = ResourceUtil.toResourceNotExisting(pageContext, strPath).getRealResource(strFile);
        } else if (strFile != null) {
            file = ResourceUtil.toResourceNotExisting(pageContext, strFile);
        } else if (strPath != null) {
            file = ResourceUtil.toResourceNotExisting(pageContext, strPath);
            // Resource dir = file.getParentResource();
            if (file.isDirectory()) {
                file = file.getRealResource(req.getURI().getPath());// TODO was getName()
                // ->http://hc.apache.org/httpclient-3.x/apidocs/org/apache/commons/httpclient/URI.html#getName()
            }

        }
        if (file != null)
            pageContext.getConfig().getSecurityManager().checkFileLocation(file);

        // filecontent
        InputStream is = null;
        if (isText && getAsBinary != GET_AS_BINARY_YES) {
            String str;
            try {

                // read content
                if (method != METHOD_HEAD) {
                    is = rsp.getContentAsStream();
                    if (is != null && isGzipEncoded(contentEncoding))
                        is = rsp.getStatusCode() != 200 ? new CachingGZIPInputStream(is)
                                : new GZIPInputStream(is);
                }
                try {
                    try {
                        str = is == null ? ""
                                : IOUtil.toString(is, responseCharset, checkRemainingTimeout().getMillis());
                    } catch (EOFException eof) {
                        if (is instanceof CachingGZIPInputStream) {
                            str = IOUtil.toString(is = ((CachingGZIPInputStream) is).getRawData(),
                                    responseCharset, checkRemainingTimeout().getMillis());
                        } else
                            throw eof;
                    }
                } catch (UnsupportedEncodingException uee) {
                    str = IOUtil.toString(is, (Charset) null, checkRemainingTimeout().getMillis());
                }
            } catch (IOException ioe) {
                throw Caster.toPageException(ioe);
            } finally {
                IOUtil.closeEL(is);
            }

            if (str == null)
                str = "";
            if (resolveurl) {
                // if(e.redirectURL!=null)url=e.redirectURL.toExternalForm();
                str = new URLResolver().transform(str, e.response.getTargetURL(), false);
            }
            cfhttp.set(KeyConstants._filecontent, str);
            try {
                if (file != null) {
                    IOUtil.write(file, str, ((PageContextImpl) pageContext).getWebCharset(), false);
                }
            } catch (IOException e1) {
            }

            if (name != null) {
                Query qry = CSVParser.toQuery(str, delimiter, textqualifier, columns, firstrowasheaders);
                pageContext.setVariable(name, qry);
            }
        }
        // Binary
        else {
            byte[] barr = null;
            if (isGzipEncoded(contentEncoding)) {
                if (method != METHOD_HEAD) {
                    is = rsp.getContentAsStream();
                    is = rsp.getStatusCode() != 200 ? new CachingGZIPInputStream(is) : new GZIPInputStream(is);
                }

                try {
                    try {
                        barr = is == null ? new byte[0] : IOUtil.toBytes(is);
                    } catch (EOFException eof) {
                        if (is instanceof CachingGZIPInputStream)
                            barr = IOUtil.toBytes(((CachingGZIPInputStream) is).getRawData());
                        else
                            throw eof;
                    }
                } catch (IOException t) {
                    throw Caster.toPageException(t);
                } finally {
                    IOUtil.closeEL(is);
                }
            } else {
                try {
                    if (method != METHOD_HEAD)
                        barr = rsp.getContentAsByteArray();
                    else
                        barr = new byte[0];
                } catch (IOException t) {
                    throw Caster.toPageException(t);
                }
            }
            // IF Multipart response get file content and parse parts
            if (barr != null) {
                if (isMultipart) {
                    cfhttp.set(KeyConstants._filecontent, MultiPartResponseUtils.getParts(barr, mimetype));
                } else {
                    cfhttp.set(KeyConstants._filecontent, barr);
                }
            } else
                cfhttp.set(KeyConstants._filecontent, "");

            if (file != null) {
                try {
                    if (barr != null)
                        IOUtil.copy(new ByteArrayInputStream(barr), file, true);
                } catch (IOException ioe) {
                    throw Caster.toPageException(ioe);
                }
            }
        }

        // header
        cfhttp.set(KeyConstants._header, raw.toString());
        if (!isStatusOK(rsp.getStatusCode())) {
            String msg = rsp.getStatusCode() + " " + rsp.getStatusText();
            cfhttp.setEL(ERROR_DETAIL, msg);
            if (throwonerror) {
                throw new HTTPException(msg, null, rsp.getStatusCode(), rsp.getStatusText(), rsp.getURL());
            }
        }

        // TODO: check if we can use statCode instead of rsp.getStatusCode() everywhere and cleanup the code
        if (cacheHandler != null && rsp.getStatusCode() == 200) {
            // add to cache
            cacheHandler.set(pageContext, cacheId, cachedWithin,
                    new HTTPCacheItem(cfhttp, url, System.nanoTime() - start));
        }
    } finally {
        if (client != null)
            client.close();
    }
}

From source file:org.opentravel.schemacompiler.repository.impl.RemoteRepositoryClient.java

/**
 * @see org.opentravel.schemacompiler.repository.Repository#unlock(org.opentravel.schemacompiler.repository.RepositoryItem,
 *      boolean)/*from ww w .j a v a 2 s .c o m*/
 */
@SuppressWarnings("unchecked")
@Override
public void unlock(RepositoryItem item, boolean commitWIP) throws RepositoryException {
    InputStream wipContent = null;
    boolean success = false;
    try {
        validateRepositoryItem(item);
        manager.getFileManager().startChangeSet();

        // Build the HTTP request for the remote service
        RepositoryItemIdentityType itemIdentity = createItemIdentity(item);
        Marshaller marshaller = RepositoryFileManager.getSharedJaxbContext().createMarshaller();
        HttpPost request = newPostRequest(UNLOCK_ENDPOINT);

        MultipartEntityBuilder mpEntity = MultipartEntityBuilder.create();
        StringWriter xmlWriter = new StringWriter();

        if (commitWIP) {
            File wipFile = manager.getFileManager().getLibraryWIPContentLocation(item.getBaseNamespace(),
                    item.getFilename());

            if (!wipFile.exists()) {
                throw new RepositoryException("The work-in-process file does not exist: " + item.getFilename());
            }
            wipContent = new FileInputStream(wipFile);
            mpEntity.addBinaryBody("fileContent", toByteArray(wipContent), ContentType.DEFAULT_BINARY,
                    item.getFilename());
            // mpEntity.addPart( "fileContent", new InputStreamBody(wipContent,
            // item.getFilename()) );
        }
        marshaller.marshal(objectFactory.createRepositoryItemIdentity(itemIdentity), xmlWriter);
        mpEntity.addTextBody("item", xmlWriter.toString(), ContentType.TEXT_XML);
        request.setEntity(mpEntity.build());

        // Send the web service request and unmarshall the updated meta-data from the response
        log.info("Sending lock request to HTTP endpoint: " + endpointUrl);
        HttpResponse response = executeWithAuthentication(request);

        if (response.getStatusLine().getStatusCode() != HTTP_RESPONSE_STATUS_OK) {
            throw new RepositoryException(getResponseErrorMessage(response));
        }
        log.info("Lock response received - Status OK");

        Unmarshaller unmarshaller = RepositoryFileManager.getSharedJaxbContext().createUnmarshaller();
        JAXBElement<LibraryInfoType> jaxbElement = (JAXBElement<LibraryInfoType>) unmarshaller
                .unmarshal(response.getEntity().getContent());

        // Update the local cache with the content we just received from the remote web service
        manager.getFileManager().saveLibraryMetadata(jaxbElement.getValue());

        // Update the local repository item with the latest state information
        ((RepositoryItemImpl) item).setState(RepositoryItemState.MANAGED_UNLOCKED);
        ((RepositoryItemImpl) item).setLockedByUser(null);

        // Force a re-download of the updated content to make sure the local copy is
        // synchronized
        // with the remote repository.
        downloadContent(item, true);

        success = true;

    } catch (JAXBException e) {
        throw new RepositoryException("The format of the library meta-data is unreadable.", e);

    } catch (IOException e) {
        throw new RepositoryException("The remote repository is unavailable.", e);

    } finally {
        // Close the WIP content input stream
        try {
            if (wipContent != null)
                wipContent.close();
        } catch (Throwable t) {
        }

        // Commit or roll back the changes based on the result of the operation
        if (success) {
            manager.getFileManager().commitChangeSet();
        } else {
            try {
                manager.getFileManager().rollbackChangeSet();
            } catch (Throwable t) {
                log.error("Error rolling back the current change set.", t);
            }
        }
    }
}