Java tutorial
/* * 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.jackrabbit.core; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Collections; import java.util.Map; import java.util.Properties; import javax.jcr.Credentials; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.Value; import org.apache.commons.collections.map.ReferenceMap; import org.apache.jackrabbit.api.JackrabbitRepository; import org.apache.jackrabbit.commons.AbstractRepository; import org.apache.jackrabbit.core.config.ConfigurationException; import org.apache.jackrabbit.core.config.RepositoryConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * A repository proxy that automatically initializes and shuts down the * underlying repository instance when the first session is opened * or the last one closed. As long as all sessions are properly closed * when no longer used, this class can be used to avoid having to explicitly * shut down the repository. */ public class TransientRepository extends AbstractRepository implements JackrabbitRepository, SessionListener { /** * The logger instance used to log the repository and session lifecycles. */ private static final Logger logger = LoggerFactory.getLogger(TransientRepository.class); /** * Name of the repository configuration file property. */ private static final String CONF_PROPERTY = "org.apache.jackrabbit.repository.conf"; /** * Default value of the repository configuration file property. */ private static final String CONF_DEFAULT = "repository.xml"; /** * Name of the repository home directory property. */ private static final String HOME_PROPERTY = "org.apache.jackrabbit.repository.home"; /** * Default value of the repository home directory property. */ private static final String HOME_DEFAULT = "repository"; /** * Factory interface for creating {@link RepositoryImpl} instances. * Used to give greater control of the repository initialization process * to users of the TransientRepository class. */ public interface RepositoryFactory { /** * Creates and initializes a repository instance. The returned instance * will be used and finally shut down by the caller of this method. * * @return initialized repository instance * @throws RepositoryException if an instance can not be created */ RepositoryImpl getRepository() throws RepositoryException; } /** * The repository configuration. Set in the constructor and used to * initialize the repository instance when the first session is opened. */ private final RepositoryFactory factory; /** * The initialized repository instance. Set when the first session is * opened and cleared when the last one is closed. */ private RepositoryImpl repository; /** * The set of open sessions. When no more open sessions remain, the * repository instance is automatically shut down until a new session * is opened. */ private final Map<Session, Session> sessions = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK); /** * The static repository descriptors. The default {@link RepositoryImpl} * descriptors are loaded as the static descriptors and used whenever a * live repository instance is not available (no open sessions). */ private final Properties descriptors; /** * The path to the repository home directory. */ private final String home; /** * Creates a transient repository proxy that will use the given repository * factory to initialize the underlying repository instances. * * @param factory repository factory * @param home the path to the repository home directory. */ public TransientRepository(RepositoryFactory factory, String home) { this.factory = factory; this.home = home; this.repository = null; this.descriptors = new Properties(); // FIXME: The current RepositoryImpl class does not allow static // access to the repository descriptors, so we need to load them // directly from the underlying property file. try { InputStream in = RepositoryImpl.class.getResourceAsStream("repository.properties"); try { descriptors.load(in); } finally { in.close(); } } catch (IOException e) { logger.warn("Unable to load static repository descriptors", e); } } /** * Creates a transient repository proxy that will use the repository * configuration file and home directory specified in system properties * <code>org.apache.jackrabbit.repository.conf</code> and * <code>org.apache.jackrabbit.repository.home</code>. If these properties * are not found, then the default values "<code>repository.xml</code>" * and "<code>repository</code>" are used. */ public TransientRepository() { this(System.getProperty(CONF_PROPERTY, CONF_DEFAULT), System.getProperty(HOME_PROPERTY, HOME_DEFAULT)); } /** * Creates a transient repository proxy that will use a copy of the given * repository configuration to initialize the underlying repository * instance. * * @param config repository configuration */ public TransientRepository(final RepositoryConfig config) { this(new RepositoryFactory() { public RepositoryImpl getRepository() throws RepositoryException { return RepositoryImpl.create(RepositoryConfig.create(config)); } }, config.getHomeDir()); } /** * Creates a transient repository proxy that will use the given repository * configuration file and home directory paths to initialize the underlying * repository instances. * * @see #TransientRepository(File, File) * @param config repository configuration file * @param home repository home directory */ public TransientRepository(String config, String home) { this(new File(config), new File(home)); } /** * Creates a transient repository proxy based on the given repository * home directory and the repository configuration file "repository.xml" * contained in that directory. * * @since Apache Jackrabbit 1.6 * @param dir repository home directory */ public TransientRepository(File dir) { this(new File(dir, "repository.xml"), dir); } /** * Creates a transient repository proxy that will use the given repository * configuration file and home directory paths to initialize the underlying * repository instances. The repository configuration file is reloaded * whenever the repository is restarted, so it is safe to modify the * configuration when all sessions have been closed. * <p> * If the given repository configuration file does not exist, then a * default configuration file is copied to the given location when the * first session starts. Similarly, if the given repository home * directory does not exist, it is automatically created when the first * session starts. This is a convenience feature designed to reduce the * need for manual configuration. * * @since Apache Jackrabbit 1.6 * @param xml repository configuration file * @param dir repository home directory */ public TransientRepository(final File xml, final File dir) { this(new RepositoryFactory() { public RepositoryImpl getRepository() throws RepositoryException { try { return RepositoryImpl.create(RepositoryConfig.install(xml, dir)); } catch (IOException e) { throw new RepositoryException("Automatic repository configuration failed", e); } catch (ConfigurationException e) { throw new RepositoryException("Invalid repository configuration file: " + xml, e); } } }, dir.getAbsolutePath()); } public TransientRepository(final Properties properties) throws ConfigurationException, IOException { this(new RepositoryFactory() { public RepositoryImpl getRepository() throws RepositoryException { try { return RepositoryImpl.create(RepositoryConfig.install(properties)); } catch (IOException e) { throw new RepositoryException("Automatic repository configuration failed: " + properties, e); } catch (ConfigurationException e) { throw new RepositoryException("Invalid repository configuration: " + properties, e); } } }, RepositoryConfig.getRepositoryHome(properties).getAbsolutePath()); } /** * @return the path to the repository home directory. */ public String getHomeDir() { return home; } /** * Starts the underlying repository. * * @throws RepositoryException if the repository cannot be started */ private synchronized void startRepository() throws RepositoryException { assert repository == null && sessions.isEmpty(); logger.debug("Initializing transient repository"); repository = factory.getRepository(); logger.info("Transient repository initialized"); } /** * Stops the underlying repository. */ private synchronized void stopRepository() { assert repository != null && sessions.isEmpty(); logger.debug("Shutting down transient repository"); repository.shutdown(); logger.info("Transient repository shut down"); repository = null; } //------------------------------------------------------------<Repository> /** * Returns the available descriptor keys. If the underlying repository * is initialized, then the call is proxied to it, otherwise the static * descriptor keys are returned. * * @return descriptor keys */ public synchronized String[] getDescriptorKeys() { if (repository != null) { return repository.getDescriptorKeys(); } else { String[] keys = Collections.list(descriptors.propertyNames()).toArray(new String[0]); Arrays.sort(keys); return keys; } } /** * Returns the identified repository descriptor. If the underlying * repository is initialized, then the call is proxied to it, otherwise * the static descriptors are used. * * @param key descriptor key * @return descriptor value * @see javax.jcr.Repository#getDescriptor(String) */ public synchronized String getDescriptor(String key) { if (repository != null) { return repository.getDescriptor(key); } else { return descriptors.getProperty(key); } } public Value getDescriptorValue(String key) { if (repository != null) { return repository.getDescriptorValue(key); } else { throw new UnsupportedOperationException("not implemented yet - see JCR-2062"); } } public Value[] getDescriptorValues(String key) { if (repository != null) { return repository.getDescriptorValues(key); } else { throw new UnsupportedOperationException("not implemented yet - see JCR-2062"); } } public boolean isSingleValueDescriptor(String key) { if (repository != null) { return repository.isSingleValueDescriptor(key); } else { throw new UnsupportedOperationException("not implemented yet - see JCR-2062"); } } /** * Logs in to the content repository. Initializes the underlying repository * instance if needed. The opened session is added to the set of open * sessions and a session listener is added to track when the session gets * closed. * * @param credentials login credentials * @param workspaceName workspace name * @return new session * @throws RepositoryException if the session could not be created * @see javax.jcr.Repository#login(Credentials,String) */ public synchronized Session login(Credentials credentials, String workspaceName) throws RepositoryException { // Start the repository if this is the first login if (repository == null) { startRepository(); } try { logger.debug("Opening a new session"); SessionImpl session = (SessionImpl) repository.login(credentials, workspaceName); sessions.put(session, session); session.addListener(this); logger.info("Session opened"); return session; } finally { // Stop the repository if the login failed // and no other sessions are active if (sessions.isEmpty()) { stopRepository(); } } } //--------------------------------------------------<JackrabbitRepository> /** * Forces all active sessions to logout. Once the last session has logged * out, the underlying repository instance will automatically be shut down. * * @see Session#logout() */ public synchronized void shutdown() { Session[] copy = sessions.keySet().toArray(new Session[0]); for (Session session : copy) { session.logout(); } } //-------------------------------------------------------<SessionListener> /** * Removes the given session from the set of open sessions. If no open * sessions remain, then the underlying repository instance is shut down. * * @param session closed session * @see SessionListener#loggedOut(SessionImpl) */ public synchronized void loggedOut(SessionImpl session) { assert sessions.containsKey(session); sessions.remove(session); logger.info("Session closed"); if (sessions.isEmpty()) { // FIXME: This is an ugly hack to avoid an infinite loop when // RepositoryImpl.shutdown() repeatedly calls logout() on all // remaining active sessions including the one that just emitted // the loggedOut() message to us! repository.loggedOut(session); stopRepository(); } } /** * Ignored. {@inheritDoc} */ public void loggingOut(SessionImpl session) { } /** * Get the current repository. * * @return the repository */ RepositoryImpl getRepository() { return repository; } }