201305.mbox/raw/%3c20130527172035.A58FB2388C7D@eris.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.webservices;
+
+    import java.io.BufferedInputStream;
+    import java.io.IOException;
+    import java.io.InputStream;
+    import java.lang.ref.SoftReference;
+    import java.lang.reflect.Constructor;
+    import java.math.BigInteger;
+    import java.net.MalformedURLException;
+    import java.net.URL;
+    import java.util.Collections;
+    import java.util.EnumMap;
+    import java.util.HashMap;
+    import java.util.Iterator;
+    import java.util.LinkedList;
+    import java.util.List;
+    import java.util.Map;
+    import java.util.concurrent.locks.ReentrantLock;
+
+    import javax.xml.namespace.QName;
+    import javax.xml.parsers.ParserConfigurationException;
+    import javax.xml.ws.BindingProvider;
+    import javax.xml.ws.Service;
+    import javax.xml.ws.WebServiceFeature;
+    import javax.xml.ws.handler.MessageContext;
+    import javax.xml.ws.http.HTTPException;
+
+    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.client.bindings.spi.http.HttpInvoker;
+    import org.apache.chemistry.opencmis.client.bindings.spi.http.Response;
+    import org.apache.chemistry.opencmis.commons.SessionParameter;
+    import org.apache.chemistry.opencmis.commons.enums.CmisVersion;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisBaseException;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisConnectionException;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisProxyAuthenticationException;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
+    import org.apache.chemistry.opencmis.commons.exceptions.CmisUnauthorizedException;
+    import org.apache.chemistry.opencmis.commons.impl.UrlBuilder;
+    import org.apache.chemistry.opencmis.commons.impl.XMLUtils;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.ACLService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.ACLServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.DiscoveryService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.DiscoveryServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.MultiFilingService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.MultiFilingServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.NavigationService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.NavigationServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.PolicyService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.PolicyServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.RelationshipService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.RelationshipServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.RepositoryService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.RepositoryServicePort;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.VersioningService;
+    import org.apache.chemistry.opencmis.commons.impl.jaxb.VersioningServicePort;
+    import org.apache.chemistry.opencmis.commons.spi.AuthenticationProvider;
+    import org.slf4j.Logger;
+    import org.slf4j.LoggerFactory;
+    import org.w3c.dom.Document;
+    import org.w3c.dom.Element;
+    import org.w3c.dom.NodeList;
+    import org.xml.sax.SAXException;
+
+    public abstract class AbstractPortProvider {
+
+        private static final Logger LOG = LoggerFactory.getLogger(AbstractPortProvider.class);
+
+        private static final int PORT_CACHE_SIZE = 5;
+
+        protected static final int CHUNK_SIZE = (64 * 1024) - 1;
+
+        protected enum CmisWebSerivcesService {
+            REPOSITORY_SERVICE("RepositoryService", false, RepositoryService.class, RepositoryServicePort.class,
+                    SessionParameter.WEBSERVICES_REPOSITORY_SERVICE,
+                    SessionParameter.WEBSERVICES_REPOSITORY_SERVICE_ENDPOINT),
+
+            NAVIGATION_SERVICE("NavigationService", false, NavigationService.class, NavigationServicePort.class,
+                    SessionParameter.WEBSERVICES_NAVIGATION_SERVICE,
+                    SessionParameter.WEBSERVICES_NAVIGATION_SERVICE_ENDPOINT),
+
+            OBJECT_SERVICE("ObjectService", true, ObjectService.class, ObjectServicePort.class,
+                    SessionParameter.WEBSERVICES_OBJECT_SERVICE, SessionParameter.WEBSERVICES_OBJECT_SERVICE_ENDPOINT),
+
+            VERSIONING_SERVICE("VersioningService", true, VersioningService.class, VersioningServicePort.class,
+                    SessionParameter.WEBSERVICES_VERSIONING_SERVICE,
+                    SessionParameter.WEBSERVICES_VERSIONING_SERVICE_ENDPOINT),
+
+            DISCOVERY_SERVICE("DiscoveryService", false, DiscoveryService.class, DiscoveryServicePort.class,
+                    SessionParameter.WEBSERVICES_DISCOVERY_SERVICE, SessionParameter.WEBSERVICES_DISCOVERY_SERVICE_ENDPOINT),
+
+            MULTIFILING_SERVICE("MultiFilingService", false, MultiFilingService.class, MultiFilingServicePort.class,
+                    SessionParameter.WEBSERVICES_MULTIFILING_SERVICE,
+                    SessionParameter.WEBSERVICES_MULTIFILING_SERVICE_ENDPOINT),
+
+            RELATIONSHIP_SERVICE("RelationshipService", false, RelationshipService.class, RelationshipServicePort.class,
+                    SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE,
+                    SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE_ENDPOINT),
+
+            POLICY_SERVICE("PolicyService", false, PolicyService.class, PolicyServicePort.class,
+                    SessionParameter.WEBSERVICES_POLICY_SERVICE, SessionParameter.WEBSERVICES_POLICY_SERVICE_ENDPOINT),
+
+            ACL_SERVICE("ACLService", false, ACLService.class, ACLServicePort.class,
+                    SessionParameter.WEBSERVICES_ACL_SERVICE, SessionParameter.WEBSERVICES_ACL_SERVICE_ENDPOINT);
+
+            private final String name;
+            private final QName qname;
+            private final boolean handlesContent;
+            private final Class<? extends Service> serviceClass;
+            private final Class<?> portClass;
+            private final String wsdlKey;
+            private final String endpointKey;
+
+            CmisWebSerivcesService(String localname, boolean handlesContent, Class<? extends Service> serviceClass,
+                    Class<?> port11Class, String wsdlKey, String endpointKey) {
+                this.name = localname;
+                this.qname = new QName("http://docs.oasis-open.org/ns/cmis/ws/200908/", localname);
+                this.handlesContent = handlesContent;
+                this.serviceClass = serviceClass;
+                this.portClass = port11Class;
+                this.wsdlKey = wsdlKey;
+                this.endpointKey = endpointKey;
+            }
+
+            public String getServiceName() {
+                return name;
+            }
+
+            public QName getQName() {
+                return qname;
+            }
+
+            public boolean handlesContent() {
+                return handlesContent;
+            }
+
+            public Class<? extends Service> getServiceClass() {
+                return serviceClass;
+            }
+
+            public Class<?> getPortClass() {
+                return portClass;
+            }
+
+            public String getWsdlKey() {
+                return wsdlKey;
+            }
+
+            public String getEndpointKey() {
+                return endpointKey;
+            }
+        }
+
+        static class CmisServiceHolder {
+            private final CmisWebSerivcesService service;
+            private SoftReference<Service> serviceObject;
+            private final URL endpointUrl;
+
+            public CmisServiceHolder(final CmisWebSerivcesService service, final URL endpointUrl) throws Exception {
+                this.service = service;
+                this.endpointUrl = endpointUrl;
+                this.serviceObject = new SoftReference<Service>(createServiceObject());
+            }
+
+            private Service createServiceObject() throws Exception {
+                final Constructor<? extends Service> serviceConstructor = service.getServiceClass().getConstructor(
+                        new Class<?>[] { URL.class, QName.class });
+                return serviceConstructor.newInstance(new Object[] { null, service.getQName() });
+            }
+
+            public CmisWebSerivcesService getService() {
+                return service;
+            }
+
+            public Service getServiceObject() throws Exception {
+                Service result = serviceObject.get();
+                if (result == null) {
+                    result = createServiceObject();
+                    serviceObject = new SoftReference<Service>(result);
+                }
+
+                return result;
+            }
+
+            public URL getEndpointUrl() {
+                return endpointUrl;
+            }
+
+            public String getServiceName() {
+                return service.getServiceName();
+            }
+        }
+
+        private BindingSession session;
+        protected boolean useCompression;
+        protected boolean useClientCompression;
+        protected String acceptLanguage;
+
+        private final ReentrantLock portObjectLock = new ReentrantLock();
+        private final EnumMap<CmisWebSerivcesService, LinkedList<SoftReference<BindingProvider>>> portObjectCache = new EnumMap<CmisWebSerivcesService, LinkedList<SoftReference<BindingProvider>>>(
+                CmisWebSerivcesService.class);
+
+        public BindingSession getSession() {
+            return session;
+        }
+
+        public void setSession(BindingSession session) {
+            this.session = session;
+
+            final Object compression = session.get(SessionParameter.COMPRESSION);
+            useCompression = (compression != null) && Boolean.parseBoolean(compression.toString());
+
+            final Object clientCompression = session.get(SessionParameter.CLIENT_COMPRESSION);
+            useClientCompression = (clientCompression != null) && Boolean.parseBoolean(clientCompression.toString());
+
+            if (session.get(CmisBindingsHelper.ACCEPT_LANGUAGE) instanceof String) {
+                acceptLanguage = session.get(CmisBindingsHelper.ACCEPT_LANGUAGE).toString();
+            }
+        }
+
+        /**
+         * Return the Repository Service port object.
+         */
+        public RepositoryServicePort getRepositoryServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.REPOSITORY_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (RepositoryServicePort) portObject;
+        }
+
+        /**
+         * Return the Navigation Service port object.
+         */
+        public NavigationServicePort getNavigationServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.NAVIGATION_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (NavigationServicePort) portObject;
+        }
+
+        /**
+         * Return the Object Service port object.
+         */
+        public ObjectServicePort getObjectServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.OBJECT_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (ObjectServicePort) portObject;
+        }
+
+        /**
+         * Return the Versioning Service port object.
+         */
+        public VersioningServicePort getVersioningServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.VERSIONING_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (VersioningServicePort) portObject;
+        }
+
+        /**
+         * Return the Discovery Service port object.
+         */
+        public DiscoveryServicePort getDiscoveryServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.DISCOVERY_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (DiscoveryServicePort) portObject;
+        }
+
+        /**
+         * Return the MultiFiling Service port object.
+         */
+        public MultiFilingServicePort getMultiFilingServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.MULTIFILING_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (MultiFilingServicePort) portObject;
+        }
+
+        /**
+         * Return the Relationship Service port object.
+         */
+        public RelationshipServicePort getRelationshipServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.RELATIONSHIP_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (RelationshipServicePort) portObject;
+        }
+
+        /**
+         * Return the Policy Service port object.
+         */
+        public PolicyServicePort getPolicyServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.POLICY_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (PolicyServicePort) portObject;
+        }
+
+        /**
+         * Return the ACL Service port object.
+         */
+        public ACLServicePort getACLServicePort(CmisVersion cmisVersion, String soapAction) {
+            BindingProvider portObject = getPortObject(CmisWebSerivcesService.ACL_SERVICE);
+            setSoapAction(portObject, soapAction, cmisVersion);
+
+            return (ACLServicePort) portObject;
+        }
+
+        public void endCall(Object portObject) {
+            AuthenticationProvider authProvider = CmisBindingsHelper.getAuthenticationProvider(session);
+            if (authProvider != null && portObject instanceof BindingProvider) {
+                BindingProvider bp = (BindingProvider) portObject;
+                String url = (String) bp.getRequestContext().get(BindingProvider.ENDPOINT_ADDRESS_PROPERTY);
+                if (bp.getResponseContext() != null) {
+                    @SuppressWarnings("unchecked")
+                    Map<String, List<String>> headers = (Map<String, List<String>>) bp.getResponseContext().get(
+                            MessageContext.HTTP_RESPONSE_HEADERS);
+                    Integer statusCode = (Integer) bp.getResponseContext().get(MessageContext.HTTP_RESPONSE_CODE);
+                    authProvider.putResponseHeaders(url, statusCode == null ? -1 : statusCode, headers);
+                }
+
+                CmisWebSerivcesService service = null;
+
+                if (portObject instanceof RepositoryServicePort) {
+                    service = CmisWebSerivcesService.REPOSITORY_SERVICE;
+                } else if (portObject instanceof NavigationServicePort) {
+                    service = CmisWebSerivcesService.NAVIGATION_SERVICE;
+                } else if (portObject instanceof ObjectServicePort) {
+                    service = CmisWebSerivcesService.OBJECT_SERVICE;
+                } else if (portObject instanceof VersioningServicePort) {
+                    service = CmisWebSerivcesService.VERSIONING_SERVICE;
+                } else if (portObject instanceof DiscoveryServicePort) {
+                    service = CmisWebSerivcesService.DISCOVERY_SERVICE;
+                } else if (portObject instanceof MultiFilingServicePort) {
+                    service = CmisWebSerivcesService.MULTIFILING_SERVICE;
+                } else if (portObject instanceof RelationshipServicePort) {
+                    service = CmisWebSerivcesService.RELATIONSHIP_SERVICE;
+                } else if (portObject instanceof PolicyServicePort) {
+                    service = CmisWebSerivcesService.POLICY_SERVICE;
+                } else if (portObject instanceof ACLServicePort) {
+                    service = CmisWebSerivcesService.ACL_SERVICE;
+                }
+
+                if (service == null) {
+                    return;
+                }
+
+                portObjectLock.lock();
+                try {
+                    LinkedList<SoftReference<BindingProvider>> queue = portObjectCache.get(service);
+                    if (queue == null) {
+                        throw new CmisRuntimeException("This is a bug!");
+                    }
+
+                    if (queue.size() < PORT_CACHE_SIZE) {
+                        queue.push(new SoftReference<BindingProvider>(bp));
+                    } else {
+                        Iterator<SoftReference<BindingProvider>> iter = queue.iterator();
+                        while (iter.hasNext()) {
+                            SoftReference<BindingProvider> ref = iter.next();
+                            if (ref.get() == null) {
+                                iter.remove();
+                                queue.push(new SoftReference<BindingProvider>(bp));
+                                break;
+                            }
+                        }
+                    }
+                } finally {
+                    portObjectLock.unlock();
+                }
+            }
+        }
+
+        // ---- internal ----
+
+        @SuppressWarnings("unchecked")
+        protected BindingProvider getPortObject(final CmisWebSerivcesService service) {
+            Map<CmisWebSerivcesService, CmisServiceHolder> serviceMap = (Map<CmisWebSerivcesService, CmisServiceHolder>) session
+                    .get(SpiSessionParameter.SERVICES);
+
+            // does the service map exist?
+            if (serviceMap == null) {
+                session.writeLock();
+                try {
+                    // try again
+                    serviceMap = (Map<CmisWebSerivcesService, CmisServiceHolder>) session.get(SpiSessionParameter.SERVICES);
+                    if (serviceMap == null) {
+                        serviceMap = new EnumMap<CmisWebSerivcesService, CmisServiceHolder>(CmisWebSerivcesService.class);
+                        session.put(SpiSessionParameter.SERVICES, serviceMap, true);
+                    }
+
+                    if (serviceMap.containsKey(service)) {
+                        return createPortObject(serviceMap.get(service));
+                    }
+
+                    // create service object
+                    CmisServiceHolder serviceholder = initServiceObject(service);
+                    serviceMap.put(service, serviceholder);
+
+                    // create port object
+                    return createPortObject(serviceholder);
+                } finally {
+                    session.writeUnlock();
+                }
+            }
+
+            // is the service in the service map?
+            if (!serviceMap.containsKey(service)) {
+                session.writeLock();
+                try {
+                    // try again
+                    if (serviceMap.containsKey(service)) {
+                        return createPortObject(serviceMap.get(service));
+                    }
+
+                    // create object
+                    CmisServiceHolder serviceholder = initServiceObject(service);
+                    serviceMap.put(service, serviceholder);
+
+                    return createPortObject(serviceholder);
+                } finally {
+                    session.writeUnlock();
+                }
+            }
+
+            return createPortObject(serviceMap.get(service));
+        }
+
+        /**
+         * Creates a service object.
+         */
+        protected CmisServiceHolder initServiceObject(final CmisWebSerivcesService service) {
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("Initializing Web Service " + service.getServiceName() + "...");
+            }
+
+            try {
+                // get URLs
+                URL endpointUrl = null;
+
+                String wsdlUrlStr = (String) session.get(service.getWsdlKey());
+                if (wsdlUrlStr != null) {
+                    endpointUrl = getEndpointUrlFromWsdl(wsdlUrlStr, service);
+                } else {
+                    String endpointUrlStr = (String) session.get(service.getEndpointKey());
+                    if (endpointUrlStr != null) {
+                        endpointUrl = new URL(endpointUrlStr);
+                    }
+                }
+
+                if (endpointUrl == null) {
+                    throw new CmisRuntimeException("Neither a WSDL URL nor an endpoint URL is specified for the service "
+                            + service.getServiceName() + "!");
+                }
+
+                // build the requested service object
+                return new CmisServiceHolder(service, endpointUrl);
+            } catch (CmisBaseException ce) {
+                throw ce;
+            } catch (Exception e) {
+                String message = "Cannot initalize Web Services service object [" + service.getServiceName() + "]: "
+                        + e.getMessage();
+
+                if (e instanceof HTTPException) {
+                    HTTPException he = (HTTPException) e;
+                    if (he.getStatusCode() == 401) {
+                        throw new CmisUnauthorizedException(message, e);
+                    } else if (he.getStatusCode() == 407) {
+                        throw new CmisProxyAuthenticationException(message, e);
+                    }
+                }
+
+                throw new CmisConnectionException(message, e);
+            }
+        }
+
+        /**
+         * Reads the URL and extracts the endpoint URL of the given service.
+         */
+        private URL getEndpointUrlFromWsdl(final String wsdlUrl, final CmisWebSerivcesService service) {
+            InputStream wsdlStream;
+            URL url;
+
+            // check the WSDL URL
+            try {
+                url = new URL(wsdlUrl);
+            } catch (MalformedURLException e) {
+                throw new CmisConnectionException("Invalid WSDL URL: " + wsdlUrl, e);
+            }
+
+            // check protocol
+            if (url.getProtocol().equalsIgnoreCase("http") || url.getProtocol().equalsIgnoreCase("https")) {
+                // HTTP URL -> use HttpInvoker to enable authentication
+                HttpInvoker hi = CmisBindingsHelper.getHttpInvoker(session);
+                Response wsdlResponse = hi.invokeGET(new UrlBuilder(wsdlUrl), session);
+
+                if (wsdlResponse.getResponseCode() != 200) {
+                    throw new CmisConnectionException("Cannot access WSDL: " + wsdlUrl, BigInteger.ZERO,
+                            wsdlResponse.getErrorContent());
+                } else {
+                    wsdlStream = wsdlResponse.getStream();
+                }
+            } else {
+                // non-HTTP URL -> just open the stream
+                try {
+                    wsdlStream = url.openStream();
+                } catch (IOException e) {
+                    throw new CmisConnectionException("Cannot access WSDL: " + wsdlUrl, e);
+                }
+            }
+
+            // parse the WSDL
+            try {
+                final Document doc = XMLUtils.parseDomDocument(new BufferedInputStream(wsdlStream, 16 * 1024));
+
+                NodeList serivceList = doc.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/", "service");
+                for (int i = 0; i < serivceList.getLength(); i++) {
+                    Element serviceNode = (Element) serivceList.item(i);
+
+                    String name = serviceNode.getAttribute("name");
+                    if (name == null) {
+                        continue;
+                    }
+
+                    if (!service.getQName().getLocalPart().equals(name)) {
+                        continue;
+                    }
+
+                    NodeList portList = ((Element) serviceNode).getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/",
+                            "port");
+                    if (portList.getLength() < 1) {
+                        throw new CmisRuntimeException("This service has no ports: " + service.getServiceName());
+                    }
+
+                    Element port = (Element) portList.item(0);
+
+                    NodeList addressList = port.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/soap/", "address");
+                    if (addressList.getLength() < 1) {
+                        throw new CmisRuntimeException("This service has no endpoint address: " + service.getServiceName());
+                    }
+
+                    Element address = (Element) addressList.item(0);
+
+                    String location = address.getAttribute("location");
+                    if (location == null) {
+                        throw new CmisRuntimeException("This service has no endpoint address: " + service.getServiceName());
+                    }
+
+                    try {
+                        return new URL(location);
+                    } catch (MalformedURLException e) {
+                        throw new CmisRuntimeException("This service provides an invalid endpoint address: "
+                                + service.getServiceName());
+                    }
+                }
+
+                throw new CmisRuntimeException("This service does not provide an endpoint address: "
+                        + service.getServiceName());
+            } catch (ParserConfigurationException pe) {
+                throw new CmisRuntimeException("Cannot parse this WSDL: " + wsdlUrl, pe);
+            } catch (SAXException se) {
+                throw new CmisRuntimeException("Cannot parse this WSDL: " + wsdlUrl, se);
+            } catch (IOException ioe) {
+                throw new CmisRuntimeException("Cannot read this WSDL: " + wsdlUrl, ioe);
+            } finally {
+                try {
+                    wsdlStream.close();
+                } catch (IOException ioe) {
+                    // ignore, there is nothing we can do
+                }
+            }
+        }
+
+        /**
+         * Sets the default HTTP headers on a {@link BindingProvider} object.
+         */
+        protected void setHTTPHeaders(BindingProvider portObject, Map<String, List<String>> httpHeaders) {
+            if (httpHeaders == null) {
+                httpHeaders = new HashMap<String, List<String>>();
+            }
+
+            // CMIS client header
+            httpHeaders.put("X-CMIS-Client", Collections.singletonList(ClientVersion.OPENCMIS_CLIENT));
+
+            // compression
+            if (useCompression) {
+                httpHeaders.put("Accept-Encoding", Collections.singletonList("gzip"));
+            }
+
+            // client compression
+            if (useClientCompression) {
+                httpHeaders.put("Content-Encoding", Collections.singletonList("gzip"));
+            }
+
+            // locale
+            if (acceptLanguage != null) {
+                httpHeaders.put("Accept-Language", Collections.singletonList(acceptLanguage));
+            }
+
+            portObject.getRequestContext().put(MessageContext.HTTP_REQUEST_HEADERS, httpHeaders);
+        }
+
+        /**
+         * Sets the endpoint URL if the URL is not <code>null</code>.
+         */
+        protected void setEndpointUrl(BindingProvider portObject, URL endpointUrl) {
+            if (endpointUrl == null) {
+                return;
+            }
+
+            portObject.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointUrl.toString());
+        }
+
+        /**
+         * Sets the SOAP Action header.
+         */
+        protected void setSoapAction(BindingProvider portObject, String soapAction, CmisVersion cmisVersion) {
+            if (cmisVersion == CmisVersion.CMIS_1_0) {
+                portObject.getRequestContext().put(BindingProvider.SOAPACTION_USE_PROPERTY, Boolean.FALSE);
+            } else {
+                portObject.getRequestContext().put(BindingProvider.SOAPACTION_USE_PROPERTY, Boolean.TRUE);
+                portObject.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY, soapAction);
+            }
+        }
+
+        /**
+         * Creates a simple port object from a CmisServiceHolder object.
+         */
+        protected BindingProvider createPortObjectFromServiceHolder(final CmisServiceHolder serviceHolder,
+                WebServiceFeature... features) throws Exception {
+            portObjectLock.lock();
+            try {
+                LinkedList<SoftReference<BindingProvider>> queue = portObjectCache.get(serviceHolder.getService());
+                if (queue == null) {
+                    queue = new LinkedList<SoftReference<BindingProvider>>();
+                    portObjectCache.put(serviceHolder.getService(), queue);
+                }
+
+                while (!queue.isEmpty()) {
+                    BindingProvider bp = queue.pop().get();
+                    if (bp != null) {

[... 21 lines stripped ...]