| /* |
| * 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.j2ee; |
| |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.IOUtils; |
| import org.apache.felix.connect.launch.PojoServiceRegistry; |
| import org.apache.felix.webconsole.WebConsoleSecurityProvider; |
| import org.apache.jackrabbit.api.JackrabbitRepository; |
| import org.apache.jackrabbit.commons.repository.RepositoryFactory; |
| import org.apache.jackrabbit.oak.run.osgi.OakOSGiRepositoryFactory; |
| import org.apache.jackrabbit.oak.run.osgi.ServiceRegistryProvider; |
| import org.apache.jackrabbit.rmi.server.RemoteAdapterFactory; |
| import org.apache.jackrabbit.rmi.server.ServerAdapterFactory; |
| import org.apache.jackrabbit.servlet.AbstractRepositoryServlet; |
| import org.osgi.framework.BundleActivator; |
| import org.osgi.framework.BundleContext; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.InetAddress; |
| import java.net.ServerSocket; |
| import java.net.UnknownHostException; |
| import java.rmi.AlreadyBoundException; |
| import java.rmi.Naming; |
| import java.rmi.NoSuchObjectException; |
| import java.rmi.Remote; |
| import java.rmi.RemoteException; |
| import java.rmi.registry.LocateRegistry; |
| import java.rmi.registry.Registry; |
| import java.rmi.server.RMIServerSocketFactory; |
| import java.rmi.server.UnicastRemoteObject; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Properties; |
| |
| import javax.jcr.Repository; |
| import javax.jcr.RepositoryException; |
| import javax.naming.InitialContext; |
| import javax.naming.NamingException; |
| import javax.servlet.ServletContext; |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| /** |
| * The RepositoryStartupServlet starts a jackrabbit repository and registers it |
| * to the JNDI environment and optional to the RMI registry. |
| * <p id="registerAlgo"> |
| * <b>Registration with RMI</b> |
| * <p> |
| * Upon successfull creation of the repository in the {@link #init()} method, |
| * the repository is registered with an RMI registry if the web application is |
| * so configured. To register with RMI, the following web application |
| * <code>init-params</code> are considered: <code>rmi-port</code> designating |
| * the port on which the RMI registry is listening, <code>rmi-host</code> |
| * designating the interface on the local host on which the RMI registry is |
| * active, <code>repository-name</code> designating the name to which the |
| * repository is to be bound in the registry, and <code>rmi-uri</code> |
| * designating an RMI URI complete with host, optional port and name to which |
| * the object is bound. |
| * <p> |
| * If the <code>rmi-uri</code> parameter is configured with a non-empty value, |
| * the <code>rmi-port</code> and <code>rmi-host</code> parameters are ignored. |
| * The <code>repository-name</code> parameter is only considered if a non-empty |
| * <code>rmi-uri</code> parameter is configured if the latter does not contain |
| * a name to which to bind the repository. |
| * <p> |
| * This is the algorithm used to find out the host, port and name for RMI |
| * registration: |
| * <ol> |
| * <li>If neither a <code>rmi-uri</code> nor a <code>rmi-host</code> nor a |
| * <code>rmi-port</code> parameter is configured, the repository is not |
| * registered with any RMI registry. |
| * <li>If a non-empty <code>rmi-uri</code> parameter is configured extract the |
| * host name (or IP address), port number and name to bind to from the |
| * URI. If the URI is not valid, host defaults to <code>0.0.0.0</code> |
| * meaning all interfaces on the local host, port defaults to the RMI |
| * default port (<code>1099</code>) and the name defaults to the value |
| * of the <code>repository-name</code> parameter. |
| * <li>If a non-empty <code>rmi-uri</code> is not configured, the host is taken |
| * from the <code>rmi-host</code> parameter, the port from the |
| * <code>rmi-port</code> parameter and the name to bind the repository to |
| * from the <code>repository-name</code> parameter. If the |
| * <code>rmi-host</code> parameter is empty or not configured, the host |
| * defaults to <code>0.0.0.0</code> meaning all interfaces on the local |
| * host. If the <code>rmi-port</code> parameter is empty, not configured, |
| * zero or a negative value, the default port for the RMI registry |
| * (<code>1099</code>) is used. |
| * </ol> |
| * <p> |
| * After finding the host and port of the registry, the RMI registry itself |
| * is acquired. It is assumed, that host and port primarily designate an RMI |
| * registry, which should be active on the local host but has not been started |
| * yet. In this case, the <code>LocateRegistry.createRegistry</code> method is |
| * called to create a registry on the local host listening on the host and port |
| * configured. If creation fails, the <code>LocateRegistry.getRegistry</code> |
| * method is called to get a remote instance of the registry. Note, that |
| * <code>getRegistry</code> does not create an actual registry on the given |
| * host/port nor does it check, whether an RMI registry is active. |
| * <p> |
| * When the registry has been retrieved, either by creation or by just creating |
| * a remote instance, the repository is bound to the configured name in the |
| * registry. |
| * <p> |
| * Possible causes for registration failures include: |
| * <ul> |
| * <li>The web application is not configured to register with an RMI registry at |
| * all. |
| * <li>The registry is expected to be running on a remote host but does not. |
| * <li>The registry is expected to be running on the local host but cannot be |
| * accessed. Reasons include another application which does not act as an |
| * RMI registry is running on the configured port and thus blocks creation |
| * of a new RMI registry. |
| * <li>An object may already be bound to the same name as is configured to be |
| * used for the repository. |
| * </ul> |
| * <p> |
| * <b>Note:</b> if a <code>bootstrap-config</code> init parameter is specified the |
| * servlet tries to read the respective resource, either as context resource or |
| * as file. The properties specified in this file override the init params |
| * specified in the <code>web.xml</code>. |
| * <p> |
| * <p> |
| * <b>Setup Wizard Functionality</b><br> |
| * When using the first time, the configuraition can miss the relevant |
| * repository parameters in the web.xml. if so, it must contain a |
| * <code>bootstrap-config</code> parameter that referrs to a propertiy file. |
| * This file must exsit for proper working. If not, the repository is not |
| * started.<br> |
| * If the servlet is not configured correctly and accessed via http, it will |
| * provide a simple wizard for the first time configuration. It propmpts for |
| * a new (or existing) repository home and will copy the templates of the |
| * repository.xml and bootstrap.properties to the respective location. |
| */ |
| public class RepositoryStartupServlet extends AbstractRepositoryServlet { |
| |
| /** |
| * the default logger |
| */ |
| private static final Logger log = LoggerFactory.getLogger(RepositoryStartupServlet.class); |
| |
| /** |
| * the context attribute name foe 'this' instance. |
| */ |
| private final static String CTX_PARAM_THIS = "repository.startup.servet"; |
| |
| /** |
| * initial param name for the bootstrap config location |
| */ |
| public final static String INIT_PARAM_BOOTSTRAP_CONFIG = "bootstrap-config"; |
| |
| /** |
| * Ugly hack to override the bootstrap file location in the test cases |
| */ |
| static String bootstrapOverride = null; |
| |
| /** |
| * the registered repository |
| */ |
| private Repository repository; |
| |
| /** |
| * the jndi context; created based on configuration |
| */ |
| private InitialContext jndiContext; |
| |
| private Registry rmiRegistry = null; |
| |
| /** |
| * Keeps a strong reference to the server side RMI repository instance to |
| * prevent the RMI distributed Garbage Collector from collecting the |
| * instance making the repository unaccessible though it should still be. |
| * This field is only set to a non-<code>null</code> value, if registration |
| * of the repository to an RMI registry succeeded in the |
| * {@link #registerRMI()} method. |
| * |
| * @see #registerRMI() |
| * @see #unregisterRMI() |
| */ |
| private Remote rmiRepository; |
| |
| /** |
| * the file to the bootstrap config |
| */ |
| private File bootstrapConfigFile; |
| |
| /** |
| * The bootstrap configuration |
| */ |
| private BootstrapConfig config; |
| |
| /** |
| * Initializes the servlet.<br> |
| * Please note that only one repository startup servlet may exist per |
| * webapp. it registers itself as context attribute and acts as singleton. |
| * |
| * @throws ServletException if a same servlet is already registered or of |
| * another initialization error occurs. |
| */ |
| public void init() throws ServletException { |
| // check if servlet is defined twice |
| if (getServletContext().getAttribute(CTX_PARAM_THIS) != null) { |
| throw new ServletException("Only one repository startup servlet allowed per web-app."); |
| } |
| getServletContext().setAttribute(CTX_PARAM_THIS, this); |
| startup(); |
| } |
| |
| /** |
| * Returns an instance of this servlet. Please note, that only 1 |
| * repository startup servlet can exist per webapp. |
| * |
| * @param context the servlet context |
| * @return this servlet |
| */ |
| public static RepositoryStartupServlet getInstance(ServletContext context) { |
| return (RepositoryStartupServlet) context.getAttribute(CTX_PARAM_THIS); |
| } |
| |
| /** |
| * Configures and starts the repository. It registers it then to the |
| * RMI registry and bind is to the JNDI context if so configured. |
| * @throws ServletException if an error occurs. |
| */ |
| public void startup() throws ServletException { |
| if (repository != null) { |
| log.error("Startup: Repository already running."); |
| throw new ServletException("Repository already running."); |
| } |
| log.info("RepositoryStartupServlet initializing..."); |
| try { |
| if (configure()) { |
| initRepository(); |
| registerRMI(); |
| registerJNDI(); |
| } |
| |
| //Once repository is initialized get its instances bounded to ServletContext |
| //via super class init |
| if (repository != null){ |
| super.init(); |
| } |
| |
| log.info("RepositoryStartupServlet initialized."); |
| } catch (ServletException e) { |
| // shutdown repository |
| shutdownRepository(); |
| log.error("RepositoryStartupServlet initializing failed: " + e, e); |
| } |
| } |
| |
| /** |
| * Does a shutdown of the repository and deregisters it from the RMI |
| * registry and unbinds if from the JNDI context if so configured. |
| */ |
| public void shutdown() { |
| if (repository == null) { |
| log.info("Shutdown: Repository already stopped."); |
| } else { |
| log.info("RepositoryStartupServlet shutting down..."); |
| unregisterOSGi(); |
| shutdownRepository(); |
| unregisterRMI(); |
| unregisterJNDI(); |
| log.info("RepositoryStartupServlet shut down."); |
| } |
| } |
| |
| /** |
| * Restarts the repository. |
| * @throws ServletException if an error occurs. |
| * @see #shutdown() |
| * @see #startup() |
| */ |
| public void restart() throws ServletException { |
| if (repository != null) { |
| shutdown(); |
| } |
| startup(); |
| } |
| |
| /** |
| * destroy the servlet |
| */ |
| public void destroy() { |
| super.destroy(); |
| shutdown(); |
| } |
| |
| /** |
| * Returns the started repository or <code>null</code> if not started |
| * yet. |
| * @return the JCR repository |
| */ |
| public Repository getRepository() { |
| return repository; |
| } |
| |
| /** |
| * Returns a repository factory that returns the repository if available |
| * or throws an exception if not. |
| * |
| * @return repository factory |
| */ |
| public RepositoryFactory getRepositoryFactory() { |
| return new RepositoryFactory() { |
| public Repository getRepository() throws RepositoryException { |
| Repository r = repository; |
| if (r != null) { |
| return repository; |
| } else { |
| throw new RepositoryException("Repository not available"); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * Reads the configuration and initializes the {@link #config} field if |
| * successful. |
| * @throws ServletException if an error occurs. |
| */ |
| private boolean configure() throws ServletException { |
| // check if there is a loadable bootstrap config |
| Properties bootstrapProps = new Properties(); |
| String bstrp = bootstrapOverride; |
| if (bstrp == null) { |
| bstrp = getServletConfig().getInitParameter(INIT_PARAM_BOOTSTRAP_CONFIG); |
| } |
| if (bstrp != null) { |
| // check if it's a web-resource |
| InputStream in = getServletContext().getResourceAsStream(bstrp); |
| if (in == null) { |
| // check if it's a file |
| bootstrapConfigFile = new File(bstrp); |
| if (bootstrapConfigFile.canRead()) { |
| try { |
| in = new FileInputStream(bootstrapConfigFile); |
| } catch (FileNotFoundException e) { |
| throw new ServletExceptionWithCause( |
| "Bootstrap configuration not found: " + bstrp, e); |
| } |
| } |
| } |
| if (in != null) { |
| try { |
| bootstrapProps.load(in); |
| } catch (IOException e) { |
| throw new ServletException( |
| "Bootstrap configuration failure: " + bstrp, e); |
| } finally { |
| try { |
| in.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| } |
| |
| // read bootstrap config |
| config = new BootstrapConfig(); |
| config.init(getServletConfig()); |
| config.init(bootstrapProps); |
| config.validate(); |
| if (!config.isValid() |
| || config.getRepositoryHome() == null) { |
| if (bstrp == null) { |
| log.error("Repository startup configuration is not valid."); |
| } else { |
| log.error("Repository startup configuration is not valid but a bootstrap config is specified."); |
| log.error("Either create the {} file or", bstrp); |
| log.error("use the '/config/index.jsp' for easy configuration."); |
| } |
| return false; |
| } else { |
| config.logInfos(); |
| return true; |
| } |
| } |
| |
| /** |
| * Creates a new Repository based on the configuration and initializes the |
| * {@link #repository} field if successful. |
| * |
| * @throws ServletException if an error occurs |
| */ |
| private void initRepository() throws ServletException { |
| // get repository config |
| File repHome; |
| try { |
| repHome = new File(config.getRepositoryHome()).getCanonicalFile(); |
| } catch (IOException e) { |
| throw new ServletExceptionWithCause( |
| "Repository configuration failure: " + config.getRepositoryHome(), e); |
| } |
| String repConfig = config.getRepositoryConfig(); |
| if (repConfig != null) { |
| File configJson = new File(repHome, repConfig); |
| if (!configJson.exists()){ |
| InputStream in = getServletContext().getResourceAsStream(repConfig); |
| if (in == null){ |
| throw new ServletException("No config file found in classpath " + repConfig); |
| } |
| OutputStream os = null; |
| try { |
| os = FileUtils.openOutputStream(configJson); |
| IOUtils.copy(in, os); |
| } catch (IOException e1) { |
| throw new ServletExceptionWithCause( |
| "Error copying the repository config json", e1); |
| } finally { |
| IOUtils.closeQuietly(os); |
| IOUtils.closeQuietly(in); |
| } |
| } |
| |
| try { |
| repository = createRepository(configJson, repHome); |
| if (getBootstrapConfig().isRepositoryCreateDefaultIndexes()){ |
| new IndexInitializer(repository).initialize(); |
| } |
| } catch (RepositoryException e) { |
| throw new ServletExceptionWithCause("Error while creating repository", e); |
| } |
| } |
| } |
| |
| /** |
| * Shuts down the repository. If the repository is an instanceof |
| * {@link JackrabbitRepository} it's {@link JackrabbitRepository#shutdown()} |
| * method is called. in any case, the {@link #repository} field is |
| * <code>nulled</code>. |
| */ |
| private void shutdownRepository() { |
| if (repository instanceof JackrabbitRepository) { |
| ((JackrabbitRepository) repository).shutdown(); |
| } |
| repository = null; |
| } |
| |
| /** |
| * Creates the repository instance for the given config and homedir. |
| * Subclasses may override this method of providing own implementations of |
| * a {@link Repository}. |
| * |
| * @param configJson input source of the repository config |
| * @param homedir the repository home directory |
| * @return a new jcr repository. |
| * @throws RepositoryException if an error during creation occurs. |
| */ |
| protected Repository createRepository(File configJson, File homedir) |
| throws RepositoryException { |
| Map<String,Object> config = new HashMap<String, Object>(); |
| config.put(OakOSGiRepositoryFactory.REPOSITORY_HOME, homedir.getAbsolutePath()); |
| config.put(OakOSGiRepositoryFactory.REPOSITORY_CONFIG_FILE, configJson.getAbsolutePath()); |
| config.put(OakOSGiRepositoryFactory.REPOSITORY_BUNDLE_FILTER, getBootstrapConfig().getBundleFilter()); |
| config.put(OakOSGiRepositoryFactory.REPOSITORY_SHUTDOWN_ON_TIMEOUT, getBootstrapConfig().isShutdownOnTimeout()); |
| config.put(OakOSGiRepositoryFactory.REPOSITORY_TIMEOUT_IN_SECS, getBootstrapConfig().getStartupTimeout()); |
| configureActivator(config); |
| //TODO oak-jcr also provides a dummy RepositoryFactory. Hence this |
| //cannot be used |
| //return JcrUtils.getRepository(config); |
| Repository repository = new OakOSGiRepositoryFactory().getRepository(config); |
| configWebConsoleSecurityProvider(repository); |
| return repository; |
| } |
| |
| private void configWebConsoleSecurityProvider(Repository repository) { |
| if (repository instanceof ServiceRegistryProvider){ |
| PojoServiceRegistry registry = ((ServiceRegistryProvider) repository).getServiceRegistry(); |
| registry.registerService(WebConsoleSecurityProvider.class.getName(), |
| new RepositorySecurityProvider(repository), null); |
| } |
| } |
| |
| private void configureActivator(Map<String, Object> config) { |
| try{ |
| config.put(BundleActivator.class.getName(), new BundleActivator() { |
| @Override |
| public void start(BundleContext bundleContext) throws Exception { |
| registerOSGi(bundleContext); |
| } |
| |
| @Override |
| public void stop(BundleContext bundleContext) throws Exception { |
| unregisterOSGi(); |
| } |
| }); |
| } catch (Throwable t){ |
| log.warn("OSGi support not present", t); |
| } |
| } |
| |
| /** |
| * Binds the repository to the JNDI context |
| * @throws ServletException if an error occurs. |
| */ |
| private void registerJNDI() throws ServletException { |
| JNDIConfig jc = config.getJndiConfig(); |
| if (jc.isValid() && jc.enabled()) { |
| try { |
| jndiContext = new InitialContext(jc.getJndiEnv()); |
| jndiContext.bind(jc.getJndiName(), repository); |
| log.info("Repository bound to JNDI with name: " + jc.getJndiName()); |
| } catch (NamingException e) { |
| throw new ServletExceptionWithCause( |
| "Unable to bind repository using JNDI: " + jc.getJndiName(), e); |
| } |
| } |
| } |
| |
| /** |
| * Unbinds the repository from the JNDI context. |
| */ |
| private void unregisterJNDI() { |
| if (jndiContext != null) { |
| try { |
| jndiContext.unbind(config.getJndiConfig().getJndiName()); |
| } catch (NamingException e) { |
| log("Error while unbinding repository from JNDI: " + e); |
| } |
| } |
| } |
| |
| /** |
| * Registers the repository to an RMI registry configured in the web |
| * application. See <a href="#registerAlgo">Registration with RMI</a> in the |
| * class documentation for a description of the algorithms used to register |
| * the repository with an RMI registry. |
| * @throws ServletException if an error occurs. |
| */ |
| private void registerRMI() { |
| RMIConfig rc = config.getRmiConfig(); |
| if (!rc.isValid() || !rc.enabled()) { |
| return; |
| } |
| |
| // try to create remote repository |
| Remote remote; |
| try { |
| Class<?> clazz = Class.forName(getRemoteFactoryDelegaterClass()); |
| RemoteFactoryDelegater rmf = (RemoteFactoryDelegater) clazz.newInstance(); |
| remote = rmf.createRemoteRepository(repository); |
| } catch (RemoteException e) { |
| log.warn("Unable to create RMI repository.", e); |
| return; |
| } catch (Throwable t) { |
| log.warn("Unable to create RMI repository." |
| + " The jcr-rmi jar might be missing.", t); |
| return; |
| } |
| |
| try { |
| System.setProperty("java.rmi.server.useCodebaseOnly", "true"); |
| Registry reg = null; |
| |
| // first try to create the registry, which will fail if another |
| // application is already running on the configured host/port |
| // or if the rmiHost is not local |
| try { |
| // find the server socket factory: use the default if the |
| // rmiHost is not configured |
| RMIServerSocketFactory sf; |
| if (rc.getRmiHost().length() > 0) { |
| log.debug("Creating RMIServerSocketFactory for host " + rc.getRmiHost()); |
| InetAddress hostAddress = InetAddress.getByName(rc.getRmiHost()); |
| sf = getRMIServerSocketFactory(hostAddress); |
| } else { |
| // have the RMI implementation decide which factory is the |
| // default actually |
| log.debug("Using default RMIServerSocketFactory"); |
| sf = null; |
| } |
| |
| // create a registry using the default client socket factory |
| // and the server socket factory retrieved above. This also |
| // binds to the server socket to the rmiHost:rmiPort. |
| reg = LocateRegistry.createRegistry(rc.rmiPort(), null, sf); |
| rmiRegistry = reg; |
| } catch (UnknownHostException uhe) { |
| // thrown if the rmiHost cannot be resolved into an IP-Address |
| // by getRMIServerSocketFactory |
| log.info("Cannot create Registry", uhe); |
| } catch (RemoteException e) { |
| // thrown by createRegistry if binding to the rmiHost:rmiPort |
| // fails, for example due to rmiHost being remote or another |
| // application already being bound to the port |
| log.info("Cannot create Registry", e); |
| } |
| |
| // if creation of the registry failed, we try to access an |
| // potentially active registry. We do not check yet, whether the |
| // registry is actually accessible. |
| if (reg == null) { |
| log.debug("Trying to access existing registry at " + rc.getRmiHost() |
| + ":" + rc.getRmiPort()); |
| try { |
| reg = LocateRegistry.getRegistry(rc.getRmiHost(), rc.rmiPort()); |
| } catch (RemoteException re) { |
| log.warn("Cannot create the reference to the registry at " |
| + rc.getRmiHost() + ":" + rc.getRmiPort(), re); |
| } |
| } |
| |
| // if we finally have a registry, register the repository with the |
| // rmiName |
| if (reg != null) { |
| log.debug("Registering repository as " + rc.getRmiName() |
| + " to registry " + reg); |
| reg.bind(rc.getRmiName(), remote); |
| |
| // when successfull, keep references |
| this.rmiRepository = remote; |
| log.info("Repository bound via RMI with name: " + rc.getRmiUri()); |
| } else { |
| log.info("RMI registry missing, cannot bind repository via RMI"); |
| } |
| } catch (RemoteException e) { |
| log.warn("Unable to bind repository via RMI: " + rc.getRmiUri(), e); |
| } catch (AlreadyBoundException e) { |
| log.warn("Unable to bind repository via RMI: " + rc.getRmiUri(), e); |
| } |
| } |
| |
| /** |
| * Unregisters the repository from the RMI registry, if it has previously |
| * been registered. |
| */ |
| private void unregisterRMI() { |
| if (rmiRepository != null) { |
| // Forcibly unexport the repository; |
| try { |
| UnicastRemoteObject.unexportObject(rmiRepository, true); |
| } catch (NoSuchObjectException e) { |
| log.warn("Odd, the RMI repository was not exported", e); |
| } |
| // drop strong reference to remote repository |
| rmiRepository = null; |
| |
| // unregister repository |
| try { |
| Naming.unbind(config.getRmiConfig().getRmiUri()); |
| } catch (Exception e) { |
| log("Error while unbinding repository from JNDI: " + e); |
| } |
| } |
| |
| if (rmiRegistry != null) { |
| try { |
| UnicastRemoteObject.unexportObject(rmiRegistry, true); |
| } catch (NoSuchObjectException e) { |
| log.warn("Odd, the RMI registry was not exported", e); |
| } |
| rmiRegistry = null; |
| } |
| } |
| |
| /** |
| * Set the BundleContext reference with ServletContext. This is then used by |
| * Felix Proxy Servlet. Kept the type as object to allow logic to work in |
| * absence of OSGi classes also. |
| * @param bundleContext |
| */ |
| private void registerOSGi(Object bundleContext) { |
| getServletContext().setAttribute("org.osgi.framework.BundleContext", bundleContext); |
| } |
| |
| private void unregisterOSGi() { |
| getServletContext().removeAttribute("org.osgi.framework.BundleContext"); |
| } |
| |
| /** |
| * Returns the config that was used to bootstrap this servlet. |
| * @return the bootstrap config or <code>null</code>. |
| */ |
| public BootstrapConfig getBootstrapConfig() { |
| return config; |
| } |
| |
| /** |
| * Return the fully qualified name of the class providing the remote |
| * repository. The class whose name is returned must implement the |
| * {@link RemoteFactoryDelegater} interface. |
| * <p> |
| * Subclasses may override this method for providing a name of a own |
| * implementation. |
| * |
| * @return getClass().getName() + "$RMIRemoteFactoryDelegater" |
| */ |
| protected String getRemoteFactoryDelegaterClass() { |
| return getClass().getName() + "$RMIRemoteFactoryDelegater"; |
| } |
| |
| /** |
| * Returns an <code>RMIServerSocketFactory</code> used to create the server |
| * socket for a locally created RMI registry. |
| * <p> |
| * This implementation returns a new instance of a simple |
| * <code>RMIServerSocketFactory</code> which just creates instances of |
| * the <code>java.net.ServerSocket</code> class bound to the given |
| * <code>hostAddress</code>. Implementations may overwrite this method to |
| * provide factory instances, which provide more elaborate server socket |
| * creation, such as SSL server sockets. |
| * |
| * @param hostAddress The <code>InetAddress</code> instance representing the |
| * the interface on the local host to which the server sockets are |
| * bound. |
| * @return A new instance of a simple <code>RMIServerSocketFactory</code> |
| * creating <code>java.net.ServerSocket</code> instances bound to |
| * the <code>rmiHost</code>. |
| */ |
| protected RMIServerSocketFactory getRMIServerSocketFactory( |
| final InetAddress hostAddress) { |
| return new RMIServerSocketFactory() { |
| public ServerSocket createServerSocket(int port) throws IOException { |
| return new ServerSocket(port, -1, hostAddress); |
| } |
| }; |
| } |
| |
| /** |
| * optional class for RMI, will only be used, if RMI server is present |
| */ |
| protected static abstract class RemoteFactoryDelegater { |
| |
| public abstract Remote createRemoteRepository(Repository repository) |
| throws RemoteException; |
| } |
| |
| /** |
| * optional class for RMI, will only be used, if RMI server is present |
| */ |
| protected static class RMIRemoteFactoryDelegater extends RemoteFactoryDelegater { |
| |
| private static final RemoteAdapterFactory FACTORY = |
| new ServerAdapterFactory(); |
| |
| public Remote createRemoteRepository(Repository repository) |
| throws RemoteException { |
| return FACTORY.getRemoteRepository(repository); |
| } |
| |
| } |
| |
| //-------------------------------------------------< Installer Routines >--- |
| |
| /** |
| * {@inheritDoc} |
| */ |
| protected void doGet(HttpServletRequest req, HttpServletResponse resp) |
| throws ServletException, IOException { |
| if (repository == null) { |
| redirect(req, resp, "/bootstrap/missing.jsp"); |
| } else { |
| redirect(req, resp, "/bootstrap/running.jsp"); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| protected void doPost(HttpServletRequest req, HttpServletResponse resp) |
| throws ServletException, IOException { |
| if (repository != null) { |
| redirect(req, resp, "/bootstrap/reconfigure.jsp"); |
| } else { |
| int rc = new Installer(bootstrapConfigFile, |
| getServletContext()).installRepository(req); |
| switch (rc) { |
| case Installer.C_INSTALL_OK: |
| // restart rep |
| restart(); |
| if (repository == null) { |
| redirect(req, resp, "/bootstrap/error.jsp"); |
| } else { |
| redirect(req, resp, "/bootstrap/success.jsp"); |
| } |
| break; |
| case Installer.C_INVALID_INPUT: |
| redirect(req, resp, "/bootstrap/missing.jsp"); |
| break; |
| case Installer.C_CONFIG_EXISTS: |
| case Installer.C_BOOTSTRAP_EXISTS: |
| case Installer.C_HOME_EXISTS: |
| redirect(req, resp, "/bootstrap/exists.jsp"); |
| break; |
| case Installer. C_HOME_MISSING: |
| case Installer.C_CONFIG_MISSING: |
| redirect(req, resp, "/bootstrap/notexists.jsp"); |
| break; |
| case Installer.C_INSTALL_ERROR: |
| redirect(req, resp, "/bootstrap/error.jsp"); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Helper function to send a redirect response respecting the context path. |
| * |
| * @param req the request |
| * @param resp the response |
| * @param loc the location for the redirect |
| * @throws ServletException if an servlet error occurs. |
| * @throws IOException if an I/O error occurs. |
| */ |
| private void redirect(HttpServletRequest req, |
| HttpServletResponse resp, String loc) |
| throws ServletException, IOException { |
| String cp = req.getContextPath(); |
| if (cp == null || cp.equals("/")) { |
| cp = ""; |
| } |
| resp.sendRedirect(cp + loc); |
| } |
| } |
| |
