| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. 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.classloader; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.UnsupportedEncodingException; |
| import java.util.List; |
| |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Workspace; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.jackrabbit.core.nodetype.InvalidNodeTypeDefException; |
| import org.apache.jackrabbit.core.nodetype.NodeTypeManagerImpl; |
| import org.apache.jackrabbit.core.nodetype.NodeTypeRegistry; |
| import org.apache.jackrabbit.core.nodetype.compact.CompactNodeTypeDefReader; |
| import org.apache.jackrabbit.core.nodetype.compact.ParseException; |
| |
| /** |
| * The <code>NodeTypeSupport</code> contains a single utility method |
| * {@link #registerNodeType(Workspace)} to register the required mixin node |
| * type <code>rep:jarFile</code> with the repository. |
| * <p> |
| * If the class loader is not used on a Jackrabbit based repository, loading |
| * this class or calling the {@link #registerNodeType(Workspace)} methods may |
| * fail with link errors. |
| * |
| * @author Felix Meschberger |
| */ |
| /* package */ class NodeTypeSupport { |
| |
| /** Default log */ |
| private static final Log log = LogFactory.getLog(NodeTypeSupport.class); |
| |
| /** |
| * The name of the class path resource containing the node type definition |
| * file used by the {@link #registerNodeType(Workspace)} method to register |
| * the required mixin node type (value is "type.cnd"). |
| */ |
| private static final String TYPE_FILE = "type.cnd"; |
| |
| /** |
| * The encoding used to read the node type definition file (value is |
| * "ISO-8859-1"). |
| */ |
| private static final String ENCODING = "ISO-8859-1"; |
| |
| /** |
| * Registers the required node type (<code>rep:jarFile</code>) with the |
| * node type manager available from the given <code>workspace</code>. |
| * <p> |
| * The <code>NodeTypeManager</code> returned by the <code>workspace</code> |
| * is expected to be of type |
| * <code>org.apache.jackrabbit.core.nodetype.NodeTypeManagerImpl</code> for |
| * the node type registration to succeed. |
| * <p> |
| * This method is not synchronized. It is up to the calling method to |
| * prevent paralell execution. |
| * |
| * @param workspace The <code>Workspace</code> providing the node type |
| * manager through which the node type is to be registered. |
| * |
| * @return <code>true</code> if this class can be used to handle archive |
| * class path entries. See above for a description of the test used. |
| */ |
| /* package */ static boolean registerNodeType(Workspace workspace) { |
| |
| // Access the node type definition file, "fail" if not available |
| InputStream ins = NodeTypeSupport.class.getResourceAsStream(TYPE_FILE); |
| if (ins == null) { |
| log.error("Node type definition file " + TYPE_FILE + |
| " not in class path. Cannot define required node type"); |
| return false; |
| } |
| |
| // Wrap the stream with a reader |
| InputStreamReader reader = null; |
| try { |
| reader = new InputStreamReader(ins, ENCODING); |
| } catch (UnsupportedEncodingException uee) { |
| log.warn("Required Encoding " + ENCODING + " not supported, " + |
| "using platform default encoding", uee); |
| |
| reader = new InputStreamReader(ins); |
| } |
| |
| try { |
| // Create a CompactNodeTypeDefReader |
| CompactNodeTypeDefReader cndReader = |
| new CompactNodeTypeDefReader(reader, TYPE_FILE); |
| |
| // Get the List of NodeTypeDef objects |
| List ntdList = cndReader.getNodeTypeDefs(); |
| |
| // Get the NodeTypeManager from the Workspace. |
| // Note that it must be cast from the generic JCR NodeTypeManager |
| // to the Jackrabbit-specific implementation. |
| NodeTypeManagerImpl ntmgr = |
| (NodeTypeManagerImpl) workspace.getNodeTypeManager(); |
| |
| // Acquire the NodeTypeRegistry |
| NodeTypeRegistry ntreg = ntmgr.getNodeTypeRegistry(); |
| |
| // register the node types from the file in a batch |
| ntreg.registerNodeTypes(ntdList); |
| |
| // get here and succeed |
| return true; |
| |
| } catch (ParseException pe) { |
| log.error("Unexpected failure to parse compact node defintion " + TYPE_FILE, pe); |
| |
| } catch (InvalidNodeTypeDefException ie) { |
| log.error("Cannot define required node type", ie); |
| |
| } catch (RepositoryException re) { |
| log.error("General problem accessing the repository", re); |
| |
| } catch (ClassCastException cce) { |
| log.error("Unexpected object type encountered", cce); |
| |
| } finally { |
| // make sure the reader is closed - expect to be non-null here ! |
| try { |
| reader.close(); |
| } catch (IOException ioe) { |
| // ignore |
| } |
| } |
| |
| // fall back to failure |
| return false; |
| } |
| } |