/** * @param ntName name * @return effective node type * @throws NoSuchNodeTypeException if node type does not exist */ public EffectiveNodeType getEffectiveNodeType(Name ntName) throws NoSuchNodeTypeException { return getEffectiveNodeType(ntName, entCache, registeredNTDefs); }
private void copyNodeTypes(NodeTypeManager ntMgr, ValueFactory valueFactory) throws RepositoryException { NodeTypeRegistry sourceRegistry = source.getNodeTypeRegistry(); List<NodeTypeTemplate> templates = Lists.newArrayList(); for (Name name : sourceRegistry.getRegisteredNodeTypes()) { String oakName = getOakName(name); // skip built-in nodetypes (OAK-1235) if (!ntMgr.hasNodeType(oakName)) { QNodeTypeDefinition def = sourceRegistry.getNodeTypeDef(name); templates.add(createNodeTypeTemplate(valueFactory, ntMgr, oakName, def)); } } ntMgr.registerNodeTypes(templates.toArray(new NodeTypeTemplate[templates.size()]), true); }
/** * Creates a new virtual node type state manager * * @param ntReg * @param obs * @param rootNodeId * @param parentId */ public VirtualNodeTypeStateManager( NodeTypeRegistry ntReg, DelegatingObservationDispatcher obs, NodeId rootNodeId, NodeId parentId) { this.ntReg = ntReg; this.obsDispatcher = obs; this.rootNodeId = rootNodeId; this.parentId = parentId; ntReg.addListener(this); }
private void copyNodeTypes() throws RepositoryException { NodeTypeRegistry sourceRegistry = source.getNodeTypeRegistry(); NodeTypeRegistry targetRegistry = target.getNodeTypeRegistry(); logger.info("Copying registered node types"); Collection<Name> existing = Arrays.asList(targetRegistry.getRegisteredNodeTypes()); Collection<QNodeTypeDefinition> register = new ArrayList<QNodeTypeDefinition>(); for (Name name : sourceRegistry.getRegisteredNodeTypes()) { // TODO: what about modified node types? if (!existing.contains(name)) { register.add(sourceRegistry.getNodeTypeDef(name)); } } try { targetRegistry.registerNodeTypes(register); } catch (InvalidNodeTypeDefException e) { throw new RepositoryException("Unable to copy node types", e); } }
Name[] ntNames = ntReg.getRegisteredNodeTypes(); NodeList indexingConfigs = configuration.getChildNodes(); for (int i = 0; i < indexingConfigs.getLength(); i++) { if (ntReg.getEffectiveNodeType(ntName).includesNodeType(element.getNodeTypeName())) { List<IndexingRule> perNtConfig = nt2rules.get(ntName); if (perNtConfig == null) { perNtConfig.add(new IndexingRule(element, ntReg.getNodeTypeDef(ntName), ntReg.getEffectiveNodeType(ntName)));
ntd = checkNtBaseSubtyping(ntd, registeredNTDefs); validateNodeTypeDef(ntd, entCache, registeredNTDefs, nsReg, false); if (!diff.isModified()) { return getEffectiveNodeType(name); checkForConflictingContent(ntd, diff); internalUnregister(name); entNew = internalRegister(ntd); persistCustomNodeTypeDefs(customNTDefs); notifyReRegistered(name);
List<QNodeTypeDefinition> registeredNodeTypeDefs = new ArrayList<QNodeTypeDefinition>(); for (QNodeTypeDefinition nodeTypeDef: nodeTypeDefs) { if (registry.isRegistered(nodeTypeDef.getName())) { registeredNodeTypeDefs.add(nodeTypeDef); } else { registry.reregisterNodeType(nodeTypeDef); nodeTypes.add(getNodeType(nodeTypeDef.getName()));
public static void initializeNodetypes(Session session, InputStream cndStream, String cndName) throws RepositoryException { try { log.debug("Initializing nodetypes from {} ", cndName); final NamespaceRegistry namespaceRegistry = session.getWorkspace().getNamespaceRegistry(); final CompactNodeTypeDefReader<QNodeTypeDefinition, NamespaceMapping> cndReader = new HippoCompactNodeTypeDefReader(new InputStreamReader(cndStream), cndName, namespaceRegistry); final List<QNodeTypeDefinition> ntdList = cndReader.getNodeTypeDefinitions(); final NodeTypeRegistry nodeTypeRegistry = ((NodeTypeManagerImpl) session.getWorkspace().getNodeTypeManager()).getNodeTypeRegistry(); for (QNodeTypeDefinition ntd : ntdList) { try { if (!nodeTypeRegistry.isRegistered(ntd.getName())) { log.debug("Registering node type {}", ntd.getName()); nodeTypeRegistry.registerNodeType(ntd); } else { log.debug("Replacing node type {}", ntd.getName()); nodeTypeRegistry.reregisterNodeType(ntd); } } catch (InvalidNodeTypeDefException e) { throw new RepositoryException("Invalid node type definition for node type " + ntd.getName(), e); } } } catch (ParseException e) { throw new RepositoryException("Failed to parse cnd " + cndName, e); } }
/** * @param name node type name * @return node type * @throws NoSuchNodeTypeException if the nodetype does not exit */ @Override public NodeTypeImpl getNodeType(Name name) throws NoSuchNodeTypeException { synchronized (ntCache) { NodeTypeImpl nt = ntCache.get(name); if (nt == null) { NodeTypeRegistry registry = context.getNodeTypeRegistry(); EffectiveNodeType ent = registry.getEffectiveNodeType(name); QNodeTypeDefinition def = registry.getNodeTypeDef(name); nt = new NodeTypeImpl( ent, def, this, context, context.getValueFactory(), context.getDataStore()); ntCache.put(name, nt); } return nt; } }
protected void setUp() throws Exception { isReadOnly = true; super.setUp(); InputStream xml = getClass().getClassLoader().getResourceAsStream(TEST_NODETYPES); QNodeTypeDefinition[] ntDefs = NodeTypeReader.read(xml); NodeTypeRegistry ntReg = ((SessionImpl) superuser).getNodeTypeManager().getNodeTypeRegistry(); if (!ntReg.isRegistered(ntDefs[0].getName())) { ntReg.registerNodeTypes(Arrays.asList(ntDefs)); } }
/** * Initially fills the cache of this registry with property type definitions * from the {@link org.apache.jackrabbit.core.nodetype.NodeTypeRegistry}. */ private void fillCache() { for (Name ntName : registry.getRegisteredNodeTypes()) { nodeTypeRegistered(ntName); } }
protected final QPropertyDefinition lookupPropDef(Name nodeTypeName, Name propName) throws RepositoryException { QPropertyDefinition[] propDefs = stateMgr.getNodeTypeRegistry().getNodeTypeDef(nodeTypeName).getPropertyDefs(); int i; for(i=0; i<propDefs.length; i++) if(propDefs[i].getName().equals(propName)) { return propDefs[i]; } throw new RepositoryException("required property "+propName+" in nodetype "+nodeTypeName+" not or badly defined"); }
/** * Scans through indexing configuration to detect un-registered node types. */ private List<Name> getUnRegisteredNodeTypes(Element indexingConfiguration) throws NamespaceException, IllegalNameException { List<Name> unRegisteredNodeTypes = new ArrayList<>(); NamespaceResolver nsResolver = new AdditionalNamespaceResolver(getNamespaces(indexingConfiguration)); NameResolver resolver = new ParsingNameResolver(NameFactoryImpl.getInstance(), nsResolver); NodeTypeRegistry ntReg = getContext().getNodeTypeRegistry(); NodeList indexingConfigs = indexingConfiguration.getChildNodes(); for (int i = 0; i < indexingConfigs.getLength(); i++) { Node configNode = indexingConfigs.item(i); if (configNode.getNodeName().equals("index-rule")) { String ntString = configNode.getAttributes().getNamedItem("nodeType").getNodeValue(); Name nodeType = resolver.getQName(ntString); if (!ntReg.isRegistered(nodeType)) { unRegisteredNodeTypes.add(nodeType); } } } return unRegisteredNodeTypes; }
Set<Name> dependents = getDependentNodeTypes(ntName); dependents.removeAll(ntNames); if (dependents.size() > 0) { checkForReferencesInContent(ntName); internalUnregister(ntNames); customNTDefs.remove(ntName); notifyUnregistered(ntNames); persistCustomNodeTypeDefs(customNTDefs);
public void shutdown() { ntRegistry.removeListener(this); monitorSession.logout(); } }
/** * {@inheritDoc} */ public void externalReregistered(QNodeTypeDefinition ntDef) throws NoSuchNodeTypeException, InvalidNodeTypeDefException, RepositoryException { reregisterNodeType(ntDef, true); }
/** * Creates a new <code>NodeTypeManagerImpl</code> instance. * * @param context the session context */ @SuppressWarnings("unchecked") public NodeTypeManagerImpl(SessionContext context) { this.context = context; // setup caches with soft references to node type // & item definition instances ntCache = new ReferenceMap(ReferenceMap.HARD, ReferenceMap.SOFT); pdCache = new ReferenceMap(ReferenceMap.HARD, ReferenceMap.SOFT); ndCache = new ReferenceMap(ReferenceMap.HARD, ReferenceMap.SOFT); NodeTypeRegistry registry = context.getNodeTypeRegistry(); rootNodeDef = new NodeDefinitionImpl( registry.getRootNodeDef(), this, context); ndCache.put(rootNodeDef.unwrap(), rootNodeDef); registry.addListener(this); }
); try { nodetypeRegistry.registerNodeType(nodeTypeDefinition); } catch (InvalidNodeTypeDefException ignore) { ); try { nodetypeRegistry.registerNodeType(nodeTypeDefinition); } catch (InvalidNodeTypeDefException ignore) {
@Override protected void checkForReferencesInContent(Name nodeTypeName) throws RepositoryException { if (ignoreNextCheckReferencesInContent.get() != null) { ignoreNextCheckReferencesInContent.remove(); return; } super.checkForReferencesInContent(nodeTypeName); }
/** * Skip checks for changes in the hippo namespaces. "Trust me, I know what I'm doing". * Also may fixup a diff when the type is only trivially extended through additional trivial supertypes. * * @param ntd The node type definition replacing the former node type definition of the same name. * @param diff The diff of the node type definition with the currently registered type * @throws javax.jcr.RepositoryException */ @Override protected void checkForConflictingContent(final QNodeTypeDefinition ntd, NodeTypeDefDiff diff) throws RepositoryException { if (ignoreNextConflictingContent.get() != null) { ignoreNextConflictingContent.remove(); return; } final Name name = ntd.getName(); final String prefix = registry.getPrefix(name.getNamespaceURI()); final String[] systemPrefixes = {"hippo", "hipposys", "hipposysedit", "hippofacnav", "hipposched"}; for (String systemPrefix : systemPrefixes) { if (prefix.equals(systemPrefix)) { return; } } if (diff.isMajor() && diff.supertypesDiff() == NodeTypeDefDiff.MAJOR) { diff = fixupTrivialSuperTypesDiff(ntd, diff); if (!diff.isModified()) { return; } } super.checkForConflictingContent(ntd, diff); }