* 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.

*/

* <code>RepositoryServiceImpl</code>...

*/

// TODO: TO-BE-FIXED. caches don't get adjusted upon removal/move of items

    private static Logger log = LoggerFactory.getLogger(RepositoryServiceImpl.class);

    private static final EventType[] ALL_EVENTS = new EventType[7];

    static {

        ALL_EVENTS[0] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.NODE_ADDED);

        ALL_EVENTS[1] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.NODE_REMOVED);

        ALL_EVENTS[2] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.PROPERTY_ADDED);

        ALL_EVENTS[3] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.PROPERTY_CHANGED);

        ALL_EVENTS[4] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.PROPERTY_REMOVED);

        ALL_EVENTS[5] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.NODE_MOVED);

        ALL_EVENTS[6] = SubscriptionImpl.getEventType(javax.jcr.observation.Event.PERSIST);

    }

    private static final SubscriptionInfo S_INFO = new SubscriptionInfo(ALL_EVENTS, true, INFINITE_TIMEOUT);

    private final IdFactory idFactory;

    private final NameFactory nameFactory;

    private final PathFactory pathFactory;

    private final QValueFactory qValueFactory;

    private final ValueFactory valueFactory;

    private final Document domFactory;

    private final NamespaceCache nsCache;

    private final URIResolverImpl uriResolver;

    private final HostConfiguration hostConfig;

    private final HashMap clients = new HashMap();

    private final HttpConnectionManager connectionManager;

    private final Map nodeTypeDefinitions = new HashMap();

    private Map descriptors;

    public RepositoryServiceImpl(String uri, IdFactory idFactory,

                                 NameFactory nameFactory,

                                 PathFactory pathFactory,

                                 QValueFactory qValueFactory) throws RepositoryException {

        if (uri == null || "".equals(uri)) {

            throw new RepositoryException("Invalid repository uri '" + uri + "'.");

        }

        if (idFactory == null || qValueFactory == null) {

            throw new RepositoryException("IdFactory and QValueFactory may not be null.");

        }

        this.idFactory = idFactory;

        this.nameFactory = nameFactory;

        this.pathFactory = pathFactory;

        this.qValueFactory = qValueFactory;

        try {

            domFactory = DomUtil.BUILDER_FACTORY.newDocumentBuilder().newDocument();

        } catch (ParserConfigurationException e) {

            throw new RepositoryException(e);

        }

        try {

            URI repositoryUri = new URI((uri.endsWith("/")) ? uri : uri+"/", true);

            hostConfig = new HostConfiguration();

            hostConfig.setHost(repositoryUri);

            nsCache = new NamespaceCache();

            uriResolver = new URIResolverImpl(repositoryUri, this, domFactory);

            NamePathResolver resolver = new NamePathResolverImpl(nsCache);

            valueFactory = new ValueFactoryQImpl(qValueFactory, resolver);

           

        } catch (URIException e) {

            throw new RepositoryException(e);

        }

        connectionManager = new MultiThreadedHttpConnectionManager();

    }

    private static void checkSessionInfo(SessionInfo sessionInfo) throws RepositoryException {

        if (!(sessionInfo instanceof SessionInfoImpl)) {

            throw new RepositoryException("Unknown SessionInfo implementation.");

        }

    }

    private static void checkSubscription(Subscription subscription) throws RepositoryException {

        if (!(subscription instanceof EventSubscriptionImpl)) {

            throw new RepositoryException("Unknown Subscription implementation.");

        }

    }

    private static boolean isUnLockMethod(DavMethod method) {

        int code = DavMethods.getMethodCode(method.getName());

        return DavMethods.DAV_UNLOCK == code;

    }

    private static void initMethod(DavMethod method, SessionInfo sessionInfo, boolean addIfHeader) throws RepositoryException {

        if (addIfHeader) {

            checkSessionInfo(sessionInfo);

            String[] locktokens = ((SessionInfoImpl) sessionInfo).getAllLockTokens();

            // TODO: ev. build tagged if header

            if (locktokens != null && locktokens.length > 0) {

                IfHeader ifH = new IfHeader(locktokens);

                method.setRequestHeader(ifH.getHeaderName(), ifH.getHeaderValue());

            }

        }

    }

    private static void initMethod(DavMethod method, BatchImpl batchImpl, boolean addIfHeader) throws RepositoryException {

        initMethod(method, batchImpl.sessionInfo,  addIfHeader);

        // add batchId as separate header

        CodedUrlHeader ch = new CodedUrlHeader(TransactionConstants.HEADER_TRANSACTIONID, batchImpl.batchId);

        method.setRequestHeader(ch.getHeaderName(), ch.getHeaderValue());

    }

    private static boolean isSameResource(String requestURI, MultiStatusResponse response) {

        String href = response.getHref();

        if (href.endsWith("/") && !requestURI.endsWith("/")) {

            href = href.substring(0, href.length() - 1);

        }

        return requestURI.equals(href);

    }

    private String saveGetIdString(ItemId id, SessionInfo sessionInfo) {

        NamePathResolver resolver = null;

        try {

            resolver = getNamePathResolver(sessionInfo);

        } catch (RepositoryException e) {

            // ignore.

        }

        return saveGetIdString(id, resolver);

    }

    private String saveGetIdString(ItemId id, NamePathResolver resolver) {

        StringBuffer bf = new StringBuffer();

        String uid = id.getUniqueID();

        if (uid != null) {

            bf.append(uid);

        }

        Path p = id.getPath();

        if (p != null) {

            if (resolver == null) {

                bf.append(p.toString());

            } else {

                try {

                    bf.append(resolver.getJCRPath(p));

                } catch (NamespaceException e) {

                    bf.append(p.toString());

                }

            }

        }

        return bf.toString();

    }

    protected NamePathResolver getNamePathResolver(SessionInfo sessionInfo) throws RepositoryException {

        checkSessionInfo(sessionInfo);

        return getNamePathResolver(((SessionInfoImpl) sessionInfo));

    }

    private NamePathResolver getNamePathResolver(SessionInfoImpl sessionInfo) {

        NamePathResolver resolver = sessionInfo.getNamePathResolver();

        if (resolver == null) {

            resolver = new NamePathResolverImpl(sessionInfo);

            ((SessionInfoImpl) sessionInfo).setNamePathResolver(resolver);

        }

        return resolver;

    }

   

    protected HttpClient getClient(SessionInfo sessionInfo) throws RepositoryException {

        HttpClient client = (HttpClient) clients.get(sessionInfo);

        if (client == null) {

            client = new HttpClient(connectionManager);

            client.setHostConfiguration(hostConfig);

            // NOTE: null credentials only work if 'missing-auth-mapping' param is

            // set on the server

            org.apache.commons.httpclient.Credentials creds = null;

            if (sessionInfo != null) {

                checkSessionInfo(sessionInfo);

                creds = ((SessionInfoImpl) sessionInfo).getCredentials().getCredentials();

                // always send authentication not waiting for 401

                client.getParams().setAuthenticationPreemptive(true);

            }

            client.getState().setCredentials(AuthScope.ANY, creds);

            clients.put(sessionInfo, client);

            log.debug("Created Client " + client + " for SessionInfo " + sessionInfo);

        }

        return client;

    }

    private void removeClient(SessionInfo sessionInfo) {

        HttpClient cl = (HttpClient) clients.remove(sessionInfo);

        log.debug("Removed Client " + cl + " for SessionInfo " + sessionInfo);

    }

    protected String getItemUri(ItemId itemId, SessionInfo sessionInfo) throws RepositoryException {

        return uriResolver.getItemUri(itemId, sessionInfo.getWorkspaceName(), sessionInfo);

    }

    private String getItemUri(NodeId parentId, Name childName,

                              SessionInfo sessionInfo) throws RepositoryException {

        String parentUri = uriResolver.getItemUri(parentId, sessionInfo.getWorkspaceName(), sessionInfo);

        NamePathResolver resolver = getNamePathResolver(sessionInfo);

        return parentUri + "/" + Text.escape(resolver.getJCRName(childName));

    }

    private NodeId getParentId(DavPropertySet propSet, SessionInfo sessionInfo)

        throws RepositoryException {

        NodeId parentId = null;

        if (propSet.contains(ItemResourceConstants.JCR_PARENT)) {

            HrefProperty parentProp = new HrefProperty(propSet.get(ItemResourceConstants.JCR_PARENT));

            String parentHref = parentProp.getHrefs().get(0).toString();

            if (parentHref != null && parentHref.length() > 0) {

                parentId = uriResolver.getNodeId(parentHref, sessionInfo);

            }

        }

        return parentId;

    }

    String getUniqueID(DavPropertySet propSet) {

        if (propSet.contains(ItemResourceConstants.JCR_UUID)) {

            return propSet.get(ItemResourceConstants.JCR_UUID).getValue().toString();

        } else {

            return null;

        }

    }

    Name getQName(DavPropertySet propSet, NamePathResolver resolver) throws RepositoryException {

        DavProperty nameProp = propSet.get(ItemResourceConstants.JCR_NAME);

        if (nameProp != null && nameProp.getValue() != null) {

            // not root node. Note that 'unespacing' is not required since

            // the jcr:name property does not provide the value in escaped form.

            String jcrName = nameProp.getValue().toString();

            try {

                return resolver.getQName(jcrName);

            } catch (NameException e) {

                throw new RepositoryException(e);

            }

        } else {

            return NameConstants.ROOT;

        }

    }

    int getIndex(DavPropertySet propSet) {

        int index = Path.INDEX_UNDEFINED;

        DavProperty indexProp = propSet.get(ItemResourceConstants.JCR_INDEX);

        if (indexProp != null && indexProp.getValue() != null) {

            index = Integer.parseInt(indexProp.getValue().toString());

        }

        return index;

    }

   

    //--------------------------------------------------------------------------

    /**

     * Execute a 'Workspace' operation.

     *

     * @param method

     * @param sessionInfo

     * @throws RepositoryException

     */

    private void execute(DavMethod method, SessionInfo sessionInfo) throws RepositoryException {

        try {

            initMethod(method, sessionInfo, !isUnLockMethod(method));

            getClient(sessionInfo).executeMethod(method);

            method.checkSuccess();

        } catch (IOException e) {

            throw new RepositoryException(e);

        } catch (DavException e) {

            throw ExceptionConverter.generate(e);

        } finally {

            if (method != null) {

                method.releaseConnection();

            }

        }

    }

    //--------------------------------------------------< RepositoryService >---

    /**

     * @see RepositoryService#getIdFactory()

     */

    public IdFactory getIdFactory() {

        return idFactory;

    }

    /**

     * @see RepositoryService#getNameFactory()

     */

    public NameFactory getNameFactory() {

        return nameFactory;

    }

    /**

     * @see RepositoryService#getPathFactory()

     */

    public PathFactory getPathFactory() {

        return pathFactory;

    }

    public QValueFactory getQValueFactory() {

        return qValueFactory;

    }

    /**

     * @see RepositoryService#getRepositoryDescriptors()

     */

    public Map getRepositoryDescriptors() throws RepositoryException {

        if (descriptors == null) {

            ReportInfo info = new ReportInfo(RepositoryDescriptorsReport.REPOSITORY_DESCRIPTORS_REPORT, DEPTH_0);

            ReportMethod method = null;

            try {

                method = new ReportMethod(uriResolver.getRepositoryUri(), info);

                getClient(null).executeMethod(method);

                method.checkSuccess();

                Document doc = method.getResponseBodyAsDocument();

                descriptors = new HashMap();

                if (doc != null) {

                    Element rootElement = doc.getDocumentElement();

                    ElementIterator nsElems = DomUtil.getChildren(rootElement, ItemResourceConstants.XML_DESCRIPTOR, ItemResourceConstants.NAMESPACE);

                    while (nsElems.hasNext()) {

                        Element elem = nsElems.nextElement();

                        String key = DomUtil.getChildText(elem, ItemResourceConstants.XML_DESCRIPTORKEY, ItemResourceConstants.NAMESPACE);

                        String descriptor = DomUtil.getChildText(elem, ItemResourceConstants.XML_DESCRIPTORVALUE, ItemResourceConstants.NAMESPACE);

                        if (key != null && descriptor != null) {

                            descriptors.put(key, descriptor);

                        } else {

                            log.error("Invalid descriptor key / value pair: " + key + " -> " + descriptor);

                        }

                    }

                }

            } catch (IOException e) {

                throw new RepositoryException(e);

            } catch (DavException e) {

                throw ExceptionConverter.generate(e);

            } finally {

                if (method != null) {

                    method.releaseConnection();

                }

            }

        }

        return descriptors;

    }

    /**

     * @see RepositoryService#obtain(Credentials, String)

     */

    public SessionInfo obtain(Credentials credentials, String workspaceName)

        throws LoginException, NoSuchWorkspaceException, RepositoryException {

        CredentialsWrapper dc = new CredentialsWrapper(credentials);

        return obtain(dc, workspaceName);

    }

    public SessionInfo obtain(SessionInfo sessionInfo, String workspaceName)

        throws LoginException, NoSuchWorkspaceException, RepositoryException {

        checkSessionInfo(sessionInfo);

        return obtain(((SessionInfoImpl)sessionInfo).getCredentials(), workspaceName);

    }

    public SessionInfo impersonate(SessionInfo sessionInfo, Credentials credentials) throws LoginException, RepositoryException {

        throw new UnsupportedOperationException("Not implemented yet.");

    }

    private SessionInfo obtain(CredentialsWrapper credentials, String workspaceName)

        throws LoginException, NoSuchWorkspaceException, RepositoryException {

        // check if the workspace with the given name is accessible

        PropFindMethod method = null;

        SessionInfoImpl sessionInfo = new SessionInfoImpl(credentials, workspaceName);

        try {

            DavPropertyNameSet nameSet = new DavPropertyNameSet();

            // for backwards compat. -> retrieve DAV:workspace if the newly

            // added property (workspaceName) is not supported by the server.

            nameSet.add(DeltaVConstants.WORKSPACE);

            nameSet.add(ItemResourceConstants.JCR_WORKSPACE_NAME);

            method = new PropFindMethod(uriResolver.getWorkspaceUri(workspaceName), nameSet, DEPTH_0);

            getClient(sessionInfo).executeMethod(method);

            MultiStatusResponse[] responses = method.getResponseBodyAsMultiStatus().getResponses();

            if (responses.length != 1) {

                throw new LoginException("Login failed: Unknown workspace '" + workspaceName+ "'.");

            }

            boolean success = false;

            DavPropertySet props = responses[0].getProperties(DavServletResponse.SC_OK);

            if (props.contains(ItemResourceConstants.JCR_WORKSPACE_NAME)) {

                String wspName = props.get(ItemResourceConstants.JCR_WORKSPACE_NAME).getValue().toString();

                if (workspaceName == null) {

                    // login with 'null' workspace name -> retrieve the effective

                    // workspace name from the property and recreate the SessionInfo.

                    sessionInfo = new SessionInfoImpl(credentials, wspName);

                } else if (!wspName.equals(workspaceName)) {

                    throw new LoginException("Login failed: Invalid workspace name '" + workspaceName + "'.");

                }

            } else if (props.contains(DeltaVConstants.WORKSPACE)) {

                String wspHref = new HrefProperty(props.get(DeltaVConstants.WORKSPACE)).getHrefs().get(0).toString();

                String wspName = Text.unescape(Text.getName(wspHref, true));

                if (!wspName.equals(workspaceName)) {

                    throw new LoginException("Login failed: Invalid workspace name " + workspaceName);

                }

            } else {

                throw new LoginException("Login failed: Unknown workspace '" + workspaceName+ "'.");

            }

        } catch (IOException e) {

            throw new RepositoryException(e.getMessage());

        } catch (DavException e) {

            throw ExceptionConverter.generate(e);

        } finally {

            if (method != null) {

                method.releaseConnection();

            }

        }

        // make sure the general namespace mappings have been loaded once

        // before additional requests are executed that rely on the namespace

        // mappings.

        if (nsCache.prefixToURI.isEmpty()) {

            try {

                getRegisteredNamespaces(sessionInfo);

            } catch (RepositoryException e) {

                // ignore

            }