src/main/java/org/apache/sling/jcr/oak/server/internal/TcclWrappingJackrabbitSession.java

/*
 * 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.sling.jcr.oak.server.internal;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.AccessControlException;

import javax.jcr.AccessDeniedException;
import javax.jcr.Credentials;
import javax.jcr.InvalidItemStateException;
import javax.jcr.InvalidSerializedDataException;
import javax.jcr.Item;
import javax.jcr.ItemExistsException;
import javax.jcr.ItemNotFoundException;
import javax.jcr.LoginException;
import javax.jcr.NamespaceException;
import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.ReferentialIntegrityException;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.ValueFactory;
import javax.jcr.Workspace;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.retention.RetentionManager;
import javax.jcr.security.AccessControlManager;
import javax.jcr.version.VersionException;

import org.apache.jackrabbit.api.JackrabbitSession;
import org.apache.jackrabbit.api.security.principal.PrincipalManager;
import org.apache.jackrabbit.api.security.user.UserManager;
import org.apache.jackrabbit.oak.Oak;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

/**
 * Custom <tt>JackrabbitSession</tt> that ensures that the correct <tt>TCCL</tt> is set in OSGi environments
 *
 *
 * @see #TcclWrappingJackrabbitSession(JackrabbitSession)
 */
public class TcclWrappingJackrabbitSession implements JackrabbitSession {

    private final JackrabbitSession wrapped;

    public TcclWrappingJackrabbitSession(JackrabbitSession wrapped) {
        this.wrapped = wrapped;
    }

    // calls setting the TCCL

    @Override
    public Session impersonate(Credentials credentials) throws LoginException, RepositoryException {

        Thread thread = Thread.currentThread();

        ClassLoader oldClassLoader = thread.getContextClassLoader();
        thread.setContextClassLoader(Oak.class.getClassLoader());

        try {
            Session session = wrapped.impersonate(credentials);
            return new TcclWrappingJackrabbitSession((JackrabbitSession) session);
        } finally {
            thread.setContextClassLoader(oldClassLoader);
        }
    }

    // only pure delegate methods below

    @Override
    public Repository getRepository() {
        return wrapped.getRepository();
    }

    @Override
    public String getUserID() {
        return wrapped.getUserID();
    }

    @Override
    public String[] getAttributeNames() {
        return wrapped.getAttributeNames();
    }

    @Override
    public Object getAttribute(String name) {
        return wrapped.getAttribute(name);
    }

    @Override
    public boolean hasPermission(String absPath, String... actions) throws RepositoryException {
        return wrapped.hasPermission(absPath, actions);
    }

    @Override
    public Workspace getWorkspace() {
        return wrapped.getWorkspace();
    }

    @Override
    public Node getRootNode() throws RepositoryException {
        return wrapped.getRootNode();
    }

    @Override
    @SuppressWarnings("deprecation")
    public Node getNodeByUUID(String uuid) throws ItemNotFoundException, RepositoryException {
        return wrapped.getNodeByUUID(uuid);
    }

    @Override
    public Node getNodeByIdentifier(String id) throws ItemNotFoundException, RepositoryException {
        return wrapped.getNodeByIdentifier(id);
    }

    @Override
    public Item getItem(String absPath) throws PathNotFoundException, RepositoryException {
        return wrapped.getItem(absPath);
    }

    @Override
    public PrincipalManager getPrincipalManager()
            throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException {
        return wrapped.getPrincipalManager();
    }

    @Override
    public Node getNode(String absPath) throws PathNotFoundException, RepositoryException {
        return wrapped.getNode(absPath);
    }

    @Override
    public Property getProperty(String absPath) throws PathNotFoundException, RepositoryException {
        return wrapped.getProperty(absPath);
    }

    @Override
    public UserManager getUserManager()
            throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException {
        return wrapped.getUserManager();
    }

    @Override
    public boolean itemExists(String absPath) throws RepositoryException {
        return wrapped.itemExists(absPath);
    }

    @Override
    public Item getItemOrNull(String absPath) throws RepositoryException {
        return wrapped.getItemOrNull(absPath);
    }

    @Override
    public boolean nodeExists(String absPath) throws RepositoryException {
        return wrapped.nodeExists(absPath);
    }

    @Override
    public Property getPropertyOrNull(String absPath) throws RepositoryException {
        return wrapped.getPropertyOrNull(absPath);
    }

    @Override
    public boolean propertyExists(String absPath) throws RepositoryException {
        return wrapped.propertyExists(absPath);
    }

    @Override
    public Node getNodeOrNull(String absPath) throws RepositoryException {
        return wrapped.getNodeOrNull(absPath);
    }

    @Override
    public void move(String srcAbsPath, String destAbsPath) throws ItemExistsException, PathNotFoundException,
            VersionException, ConstraintViolationException, LockException, RepositoryException {
        wrapped.move(srcAbsPath, destAbsPath);
    }

    @Override
    public void removeItem(String absPath) throws VersionException, LockException, ConstraintViolationException,
            AccessDeniedException, RepositoryException {
        wrapped.removeItem(absPath);
    }

    @Override
    public void save() throws AccessDeniedException, ItemExistsException, ReferentialIntegrityException,
            ConstraintViolationException, InvalidItemStateException, VersionException, LockException,
            NoSuchNodeTypeException, RepositoryException {
        wrapped.save();
    }

    @Override
    public void refresh(boolean keepChanges) throws RepositoryException {
        wrapped.refresh(keepChanges);
    }

    @Override
    public boolean hasPendingChanges() throws RepositoryException {
        return wrapped.hasPendingChanges();
    }

    @Override
    public ValueFactory getValueFactory() throws UnsupportedRepositoryOperationException, RepositoryException {
        return wrapped.getValueFactory();
    }

    @Override
    public boolean hasPermission(String absPath, String actions) throws RepositoryException {
        return wrapped.hasPermission(absPath, actions);
    }

    @Override
    public void checkPermission(String absPath, String actions) throws AccessControlException, RepositoryException {
        wrapped.checkPermission(absPath, actions);
    }

    @Override
    public boolean hasCapability(String methodName, Object target, Object[] arguments) throws RepositoryException {
        return wrapped.hasCapability(methodName, target, arguments);
    }

    @Override
    public ContentHandler getImportContentHandler(String parentAbsPath, int uuidBehavior) throws PathNotFoundException,
            ConstraintViolationException, VersionException, LockException, RepositoryException {
        return wrapped.getImportContentHandler(parentAbsPath, uuidBehavior);
    }

    @Override
    public void importXML(String parentAbsPath, InputStream in, int uuidBehavior)
            throws IOException, PathNotFoundException, ItemExistsException, ConstraintViolationException,
            VersionException, InvalidSerializedDataException, LockException, RepositoryException {
        wrapped.importXML(parentAbsPath, in, uuidBehavior);
    }

    @Override
    public void exportSystemView(String absPath, ContentHandler contentHandler, boolean skipBinary, boolean noRecurse)
            throws PathNotFoundException, SAXException, RepositoryException {
        wrapped.exportSystemView(absPath, contentHandler, skipBinary, noRecurse);
    }

    @Override
    public void exportSystemView(String absPath, OutputStream out, boolean skipBinary, boolean noRecurse)
            throws IOException, PathNotFoundException, RepositoryException {
        wrapped.exportSystemView(absPath, out, skipBinary, noRecurse);
    }

    @Override
    public void exportDocumentView(String absPath, ContentHandler contentHandler, boolean skipBinary, boolean noRecurse)
            throws PathNotFoundException, SAXException, RepositoryException {
        wrapped.exportDocumentView(absPath, contentHandler, skipBinary, noRecurse);
    }

    @Override
    public void exportDocumentView(String absPath, OutputStream out, boolean skipBinary, boolean noRecurse)
            throws IOException, PathNotFoundException, RepositoryException {
        wrapped.exportDocumentView(absPath, out, skipBinary, noRecurse);
    }

    @Override
    public void setNamespacePrefix(String prefix, String uri) throws NamespaceException, RepositoryException {
        wrapped.setNamespacePrefix(prefix, uri);
    }

    @Override
    public String[] getNamespacePrefixes() throws RepositoryException {
        return wrapped.getNamespacePrefixes();
    }

    @Override
    public String getNamespaceURI(String prefix) throws NamespaceException, RepositoryException {
        return wrapped.getNamespaceURI(prefix);
    }

    @Override
    public String getNamespacePrefix(String uri) throws NamespaceException, RepositoryException {
        return wrapped.getNamespacePrefix(uri);
    }

    @Override
    public void logout() {
        wrapped.logout();
    }

    @Override
    public boolean isLive() {
        return wrapped.isLive();
    }

    @Override
    @SuppressWarnings("deprecation")
    public void addLockToken(String lt) {
        wrapped.addLockToken(lt);
    }

    @Override
    @SuppressWarnings("deprecation")
    public String[] getLockTokens() {
        return wrapped.getLockTokens();
    }

    @Override
    @SuppressWarnings("deprecation")
    public void removeLockToken(String lt) {
        wrapped.removeLockToken(lt);
    }

    @Override
    public AccessControlManager getAccessControlManager()
            throws UnsupportedRepositoryOperationException, RepositoryException {
        return wrapped.getAccessControlManager();
    }

    @Override
    public RetentionManager getRetentionManager() throws UnsupportedRepositoryOperationException, RepositoryException {
        return wrapped.getRetentionManager();
    }
}