SystemNamespaceRegistry.java

/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed 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.modeshape.jcr;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.modeshape.common.annotation.ThreadSafe;
import org.modeshape.common.util.CheckArg;
import org.modeshape.common.logging.Logger;
import org.modeshape.jcr.cache.SessionCache;
import org.modeshape.jcr.value.Name;
import org.modeshape.jcr.value.NamespaceRegistry;
import org.modeshape.jcr.value.basic.SimpleNamespaceRegistry;

/**
 * A {@link NamespaceRegistry} implementation that stores the namespaces in the '/jcr:system' area as individual nodes for each
 * namespace.
 */
@ThreadSafe
public class SystemNamespaceRegistry implements NamespaceRegistry {

    public static final Name URI_PROPERTY_NAME = ModeShapeLexicon.URI;
    public static final Name GENERATED_PROPERTY_NAME = ModeShapeLexicon.GENERATED;

    private final JcrRepository.RunningState repository;
    private final SimpleNamespaceRegistry cache;
    private ExecutionContext context;
    private final ReadWriteLock namespacesLock = new ReentrantReadWriteLock();
    private final Logger logger = Logger.getLogger(getClass());

    SystemNamespaceRegistry( JcrRepository.RunningState repository ) {
        this.repository = repository;
        this.cache = new SimpleNamespaceRegistry();
        // Pre-load all of the built-in namespaces ...
        this.cache.register(new ExecutionContext().getNamespaceRegistry().getNamespaces());
    }

    void setContext( ExecutionContext context ) {
        this.context = context;
    }

    /**
     * Refresh the node types from the stored representation.
     * 
     * @return true if there was at least one node type found, or false if there were none
     */
    protected boolean refreshFromSystem() {
        Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            // Re-read and re-register all of the namespaces ...
            SessionCache systemCache = repository.createSystemSession(context, false);
            SystemContent system = new SystemContent(systemCache);
            Collection<Namespace> namespaces = system.readAllNamespaces();
            if (namespaces.isEmpty()) return false;
            this.cache.clear();
            this.cache.register(namespaces);
        } catch (Throwable e) {
            logger.error(e, JcrI18n.errorRefreshingNodeTypes, repository.name());
        } finally {
            lock.unlock();
        }
        return true;
    }

    private final SystemContent systemContent( boolean readOnly ) {
        SessionCache systemCache = repository.createSystemSession(context, readOnly);
        return new SystemContent(systemCache);
    }

    @Override
    public String getNamespaceForPrefix( String prefix ) {
        Lock lock = this.namespacesLock.readLock();
        try {
            lock.lock();
            CheckArg.isNotNull(prefix, "prefix");
            return cache.getNamespaceForPrefix(prefix);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String getPrefixForNamespaceUri( String namespaceUri,
                                            boolean generateIfMissing ) {
        CheckArg.isNotNull(namespaceUri, "namespaceUri");
        Lock lock = this.namespacesLock.readLock();
        try {
            lock.lock();
            // Try the cache first ...
            String prefix = cache.getPrefixForNamespaceUri(namespaceUri, false);
            if (prefix == null && generateIfMissing) {
                SystemContent systemContent = systemContent(!generateIfMissing);
                prefix = systemContent.readNamespacePrefix(namespaceUri, generateIfMissing);
                if (prefix != null) {
                    systemContent.save();
                    cache.register(prefix, namespaceUri);
                }
            }
            return prefix;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public boolean isRegisteredNamespaceUri( String namespaceUri ) {
        CheckArg.isNotNull(namespaceUri, "namespaceUri");
        Lock lock = this.namespacesLock.readLock();
        try {
            lock.lock();
            return cache.isRegisteredNamespaceUri(namespaceUri);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String getDefaultNamespaceUri() {
        return this.getNamespaceForPrefix("");
    }

    @Override
    public void register( Iterable<Namespace> namespaces ) {
        final Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            Map<String, String> urisByPrefix = new HashMap<String, String>();
            for (Namespace namespace : namespaces) {
                urisByPrefix.put(namespace.getPrefix(), namespace.getNamespaceUri());
            }
            register(urisByPrefix);
        } finally {
            lock.unlock();
        }
    }

    /**
     * Register a set of namespaces.
     * 
     * @param namespaceUrisByPrefix the map of new namespace URIs by their prefix
     */
    public void register( Map<String, String> namespaceUrisByPrefix ) {
        if (namespaceUrisByPrefix == null || namespaceUrisByPrefix.isEmpty()) return;
        final Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            SystemContent systemContent = systemContent(false);
            systemContent.registerNamespaces(namespaceUrisByPrefix);
            systemContent.save();
            for (Map.Entry<String, String> entry : namespaceUrisByPrefix.entrySet()) {
                String prefix = entry.getKey().trim();
                String uri = entry.getValue().trim();
                if (prefix.length() == 0) continue;
                this.cache.register(prefix, uri);
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String register( String prefix,
                            String namespaceUri ) {
        CheckArg.isNotNull(namespaceUri, "namespaceUri");
        namespaceUri = namespaceUri.trim();
        final Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            // Register it in the cache first ...
            String previousCachedUriForPrefix = this.cache.register(prefix, namespaceUri);
            if (!namespaceUri.equals(previousCachedUriForPrefix)) {
                // And register it in the source ...
                SystemContent systemContent = systemContent(false);
                systemContent.registerNamespaces(Collections.singletonMap(prefix, namespaceUri));
                systemContent.save();
            }
            return previousCachedUriForPrefix;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public boolean unregister( String namespaceUri ) {
        CheckArg.isNotNull(namespaceUri, "namespaceUri");
        namespaceUri = namespaceUri.trim();
        final Lock lock = this.namespacesLock.writeLock();
        try {
            lock.lock();
            // Remove it from the cache ...
            boolean found = this.cache.unregister(namespaceUri);
            // Then from the source ...
            SystemContent systemContent = systemContent(false);
            boolean foundPersistent = systemContent.unregisterNamespace(namespaceUri);
            systemContent.save();
            return foundPersistent || found;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public Set<String> getRegisteredNamespaceUris() {
        final Lock lock = this.namespacesLock.readLock();
        try {
            lock.lock();
            // Just return what's in the cache ...
            return cache.getRegisteredNamespaceUris();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public Set<Namespace> getNamespaces() {
        final Lock lock = this.namespacesLock.readLock();
        try {
            lock.lock();
            // Just return what's in the cache ...
            return cache.getNamespaces();
        } finally {
            lock.unlock();
        }
    }

    /**
     * {@inheritDoc}
     * 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        List<Namespace> namespaces = new ArrayList<Namespace>(getNamespaces());
        Collections.sort(namespaces);
        return namespaces.toString();
    }
}