201504.mbox/raw/%3c20150406171057.2991BAC0E2F@hades.apache.org%3e

+
+    /*
+     * 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.chemistry.opencmis.client.bindings.spi.http;
+
+    import static org.apache.chemistry.opencmis.commons.impl.CollectionsHelper.isNotEmpty;
+
+    import java.io.BufferedOutputStream;
+    import java.io.ByteArrayInputStream;
+    import java.io.IOException;
+    import java.io.InputStream;
+    import java.io.OutputStream;
+    import java.math.BigInteger;
+    import java.net.Socket;
+    import java.util.ArrayList;
+    import java.util.HashMap;
+    import java.util.List;
+    import java.util.Map;
+    import java.util.zip.GZIPOutputStream;
+
+    import javax.net.ssl.HostnameVerifier;
+    import javax.net.ssl.SSLException;
+    import javax.net.ssl.SSLSocket;
+
+    import org.apache.chemistry.opencmis.client.bindings.impl.ClientVersion;
+    import org.apache.chemistry.opencmis.client.bindings.impl.CmisBindingsHelper;
+    import org.apache.chemistry.opencmis.client.bindings.spi.BindingSession;
+    import org.apache.chemistry.opencmis.commons.SessionParameter;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisConnectionException;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
+    import org.apache.chemistry.opencmis.commons.impl.IOUtils;
+    import org.apache.chemistry.opencmis.commons.impl.UrlBuilder;
+    import org.apache.chemistry.opencmis.commons.spi.AuthenticationProvider;
+    import org.apache.http.Header;
+    import org.apache.http.HttpEntity;
+    import org.apache.http.HttpResponse;
+    import org.apache.http.HttpVersion;
+    import org.apache.http.client.HttpClient;
+    import org.apache.http.client.methods.HttpDelete;
+    import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+    import org.apache.http.client.methods.HttpGet;
+    import org.apache.http.client.methods.HttpPost;
+    import org.apache.http.client.methods.HttpPut;
+    import org.apache.http.client.methods.HttpRequestBase;
+    import org.apache.http.conn.ssl.X509HostnameVerifier;
+    import org.apache.http.entity.AbstractHttpEntity;
+    import org.apache.http.impl.client.DefaultHttpClient;
+    import org.apache.http.params.BasicHttpParams;
+    import org.apache.http.params.HttpConnectionParams;
+    import org.apache.http.params.HttpParams;
+    import org.apache.http.params.HttpProtocolParams;
+    import org.slf4j.Logger;
+    import org.slf4j.LoggerFactory;
+
+    /**
+     * A {@link HttpInvoker} that uses The Apache HTTP client.
+     */
+    public abstract class AbstractApacheClientHttpInvoker implements HttpInvoker {
+
+        protected static final Logger LOG = LoggerFactory.getLogger(AbstractApacheClientHttpInvoker.class);
+
+        protected static final String HTTP_CLIENT = "org.apache.chemistry.opencmis.client.bindings.spi.http.ApacheClientHttpInvoker.httpClient";
+        protected static final int BUFFER_SIZE = 2 * 1024 * 1024;
+
+        public Response invokeGET(UrlBuilder url, BindingSession session) {
+            return invoke(url, "GET", null, null, null, session, null, null);
+        }
+
+        public Response invokeGET(UrlBuilder url, BindingSession session, BigInteger offset, BigInteger length) {
+            return invoke(url, "GET", null, null, null, session, offset, length);
+        }
+
+        public Response invokePOST(UrlBuilder url, String contentType, Output writer, BindingSession session) {
+            return invoke(url, "POST", contentType, null, writer, session, null, null);
+        }
+
+        public Response invokePUT(UrlBuilder url, String contentType, Map<String, String> headers, Output writer,
+                BindingSession session) {
+            return invoke(url, "PUT", contentType, headers, writer, session, null, null);
+        }
+
+        public Response invokeDELETE(UrlBuilder url, BindingSession session) {
+            return invoke(url, "DELETE", null, null, null, session, null, null);
+        }
+
+        protected Response invoke(UrlBuilder url, String method, String contentType, Map<String, String> headers,
+                final Output writer, final BindingSession session, BigInteger offset, BigInteger length) {
+            int respCode = -1;
+
+            try {
+                // log before connect
+                if (LOG.isDebugEnabled()) {
+                    LOG.debug("Session {}: {} {}", session.getSessionId(), method, url);
+                }
+
+                // get HTTP client object from session
+                DefaultHttpClient httpclient = (DefaultHttpClient) session.get(HTTP_CLIENT);
+                if (httpclient == null) {
+                    session.writeLock();
+                    try {
+                        httpclient = (DefaultHttpClient) session.get(HTTP_CLIENT);
+                        if (httpclient == null) {
+                            httpclient = createHttpClient(url, session);
+                            session.put(HTTP_CLIENT, httpclient, true);
+                        }
+                    } finally {
+                        session.writeUnlock();
+                    }
+                }
+
+                HttpRequestBase request = null;
+
+                if ("GET".equals(method)) {
+                    request = new HttpGet(url.toString());
+                } else if ("POST".equals(method)) {
+                    request = new HttpPost(url.toString());
+                } else if ("PUT".equals(method)) {
+                    request = new HttpPut(url.toString());
+                } else if ("DELETE".equals(method)) {
+                    request = new HttpDelete(url.toString());
+                } else {
+                    throw new CmisRuntimeException("Invalid HTTP method!");
+                }
+
+                // set content type
+                if (contentType != null) {
+                    request.setHeader("Content-Type", contentType);
+                }
+                // set other headers
+                if (headers != null) {
+                    for (Map.Entry<String, String> header : headers.entrySet()) {
+                        request.addHeader(header.getKey(), header.getValue());
+                    }
+                }
+
+                // authenticate
+                AuthenticationProvider authProvider = CmisBindingsHelper.getAuthenticationProvider(session);
+                if (authProvider != null) {
+                    Map<String, List<String>> httpHeaders = authProvider.getHTTPHeaders(url.toString());
+                    if (httpHeaders != null) {
+                        for (Map.Entry<String, List<String>> header : httpHeaders.entrySet()) {
+                            if (header.getKey() != null && isNotEmpty(header.getValue())) {
+                                String key = header.getKey();
+                                if (key.equalsIgnoreCase("user-agent")) {
+                                    request.setHeader("User-Agent", header.getValue().get(0));
+                                } else {
+                                    for (String value : header.getValue()) {
+                                        if (value != null) {
+                                            request.addHeader(key, value);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // range
+                if ((offset != null) || (length != null)) {
+                    StringBuilder sb = new StringBuilder("bytes=");
+
+                    if ((offset == null) || (offset.signum() == -1)) {
+                        offset = BigInteger.ZERO;
+                    }
+
+                    sb.append(offset.toString());
+                    sb.append('-');
+
+                    if ((length != null) && (length.signum() == 1)) {
+                        sb.append(offset.add(length.subtract(BigInteger.ONE)).toString());
+                    }
+
+                    request.setHeader("Range", sb.toString());
+                }
+
+                // compression
+                Object compression = session.get(SessionParameter.COMPRESSION);
+                if ((compression != null) && Boolean.parseBoolean(compression.toString())) {
+                    request.setHeader("Accept-Encoding", "gzip,deflate");
+                }
+
+                // locale
+                if (session.get(CmisBindingsHelper.ACCEPT_LANGUAGE) instanceof String) {
+                    request.setHeader("Accept-Language", session.get(CmisBindingsHelper.ACCEPT_LANGUAGE).toString());
+                }
+
+                // send data
+                if (writer != null) {
+                    Object clientCompression = session.get(SessionParameter.CLIENT_COMPRESSION);
+                    final boolean clientCompressionFlag = (clientCompression != null)
+                            && Boolean.parseBoolean(clientCompression.toString());
+                    if (clientCompressionFlag) {
+                        request.setHeader("Content-Encoding", "gzip");
+                    }
+
+                    AbstractHttpEntity streamEntity = new AbstractHttpEntity() {
+                        @Override
+                        public boolean isChunked() {
+                            return true;
+                        }
+
+                        public boolean isRepeatable() {
+                            return false;
+                        }
+
+                        public long getContentLength() {
+                            return -1;
+                        }
+
+                        public boolean isStreaming() {
+                            return false;
+                        }
+
+                        public InputStream getContent() throws IOException {
+                            throw new UnsupportedOperationException();
+                        }
+
+                        public void writeTo(final OutputStream outstream) throws IOException {
+                            OutputStream connOut = null;
+
+                            if (clientCompressionFlag) {
+                                connOut = new GZIPOutputStream(outstream, 4096);
+                            } else {
+                                connOut = outstream;
+                            }
+
+                            OutputStream out = new BufferedOutputStream(connOut, BUFFER_SIZE);
+                            try {
+                                writer.write(out);
+                            } catch (IOException ioe) {
+                                throw ioe;
+                            } catch (Exception e) {
+                                throw new IOException(e);
+                            }
+                            out.flush();
+
+                            if (connOut instanceof GZIPOutputStream) {
+                                ((GZIPOutputStream) connOut).finish();
+                            }
+                        }
+                    };
+                    ((HttpEntityEnclosingRequestBase) request).setEntity(streamEntity);
+                }
+
+                // connect
+                HttpResponse response = httpclient.execute(request);
+                HttpEntity entity = response.getEntity();
+
+                // get stream, if present
+                respCode = response.getStatusLine().getStatusCode();
+                InputStream inputStream = null;
+                InputStream errorStream = null;
+
+                if ((respCode == 200) || (respCode == 201) || (respCode == 203) || (respCode == 206)) {
+                    if (entity != null) {
+                        inputStream = entity.getContent();
+                    } else {
+                        inputStream = new ByteArrayInputStream(new byte[0]);
+                    }
+                } else {
+                    if (entity != null) {
+                        errorStream = entity.getContent();
+                    } else {
+                        errorStream = new ByteArrayInputStream(new byte[0]);
+                    }
+                }
+
+                // collect headers
+                Map<String, List<String>> responseHeaders = new HashMap<String, List<String>>();
+                for (Header header : response.getAllHeaders()) {
+                    List<String> values = responseHeaders.get(header.getName());
+                    if (values == null) {
+                        values = new ArrayList<String>();
+                        responseHeaders.put(header.getName(), values);
+                    }
+                    values.add(header.getValue());
+                }
+
+                // log after connect
+                if (LOG.isTraceEnabled()) {
+                    LOG.trace("Session {}: {} {} > Headers: {}", session.getSessionId(), method, url,
+                            responseHeaders.toString());
+                }
+
+                // forward response HTTP headers
+                if (authProvider != null) {
+                    authProvider.putResponseHeaders(url.toString(), respCode, responseHeaders);
+                }
+
+                // get the response
+                return new Response(respCode, response.getStatusLine().getReasonPhrase(), responseHeaders, inputStream,
+                        errorStream);
+            } catch (IOException e) {
+                String status = (respCode > 0 ? " (HTTP status code " + respCode + ")" : "");
+                throw new CmisConnectionException("Cannot access \"" + url + "\"" + status + ": " + e.getMessage(), e);
+            }
+        }
+
+        /**
+         * Creates default params for the Apache HTTP Client.
+         */
+        protected HttpParams createDefaultHttpParams(BindingSession session) {
+            HttpParams params = new BasicHttpParams();
+
+            HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
+            HttpProtocolParams.setUserAgent(params, ClientVersion.OPENCMIS_CLIENT);
+            HttpProtocolParams.setContentCharset(params, IOUtils.UTF8);
+            HttpProtocolParams.setUseExpectContinue(params, true);
+
+            HttpConnectionParams.setStaleCheckingEnabled(params, true);
+
+            int connectTimeout = session.get(SessionParameter.CONNECT_TIMEOUT, -1);
+            if (connectTimeout >= 0) {
+                HttpConnectionParams.setConnectionTimeout(params, connectTimeout);
+            }
+
+            int readTimeout = session.get(SessionParameter.READ_TIMEOUT, -1);
+            if (readTimeout >= 0) {
+                HttpConnectionParams.setSoTimeout(params, readTimeout);
+            }
+
+            return params;
+        }
+
+        /**
+         * Verifies a hostname with the given verifier.
+         */
+        protected void verify(HostnameVerifier verifier, String host, SSLSocket sslSocket) throws IOException {
+            try {
+                if (verifier instanceof X509HostnameVerifier) {
+                    ((X509HostnameVerifier) verifier).verify(host, sslSocket);
+                } else {
+                    if (!verifier.verify(host, sslSocket.getSession())) {
+                        throw new SSLException("Hostname in certificate didn't match: <" + host + ">");
+                    }
+                }
+            } catch (IOException ioe) {
+                closeSocket(sslSocket);
+                throw ioe;
+            }
+        }
+
+        /**
+         * Closes the given socket and ignores exceptions.
+         */
+        protected void closeSocket(Socket socket) {
+            try {
+                socket.close();
+            } catch (IOException ioe) {
+                // ignore
+            }
+        }
+
+        /**
+         * Creates the {@link HttpClient} instance.
+         */
+        protected abstract DefaultHttpClient createHttpClient(UrlBuilder url, BindingSession session);
+    }
+