/** * Registers a new node type for the given repository and type. * @throws RepositoryException when node type can't be registered. Most often this happens when the node type of given name already exists or when the definition is invalid */ public static void registerNodeType(TypeDefinition type) throws RepositoryException { String nodeTypes = null; nodeTypes = type.getNodeTypes(); // default value if (StringUtils.isEmpty(nodeTypes)) { nodeTypes = DataModule.NODE_TYPE_DEF_TEMPLATE.format(new String[] { type.getName() }); } ContentRepository.getRepositoryProvider(DataModule.WORKSPACE).registerNodeTypes(new ByteArrayInputStream(nodeTypes.getBytes())); }
private void registerNameSpacesAndNodeTypes(String physicalWorkspaceName, RepositoryDefinition repositoryDefinition, Provider provider) { try { Session session = provider.getSystemSession(physicalWorkspaceName); try { provider.registerNamespace(RepositoryConstants.NAMESPACE_PREFIX, RepositoryConstants.NAMESPACE_URI, session.getWorkspace()); provider.registerNodeTypes(); } finally { session.logout(); } } catch (RepositoryException e) { log.error("Failed to initialize workspace {} in repository {}", physicalWorkspaceName, repositoryDefinition.getName(), e); } }
@Override public void loadWorkspace(String repositoryId, String physicalWorkspaceName) throws RepositoryException { String logicalWorkspaceName; // fallback to old pattern if repo id is empty if (StringUtils.isNotBlank(repositoryId) && (RepositoryConstants.SYSTEM.equals(physicalWorkspaceName) || RepositoryConstants.VERSION_STORE.equals(physicalWorkspaceName))) { logicalWorkspaceName = repositoryId + "-" + physicalWorkspaceName; } else { logicalWorkspaceName = physicalWorkspaceName; } log.info("Loading workspace {} (logical name {}).", physicalWorkspaceName, logicalWorkspaceName); workspaceMapping.addWorkspaceMapping(new WorkspaceMappingDefinition(logicalWorkspaceName, repositoryId, physicalWorkspaceName)); Provider provider = getRepositoryProvider(repositoryId); provider.registerWorkspace(physicalWorkspaceName); RepositoryDefinition repositoryDefinition = workspaceMapping.getRepositoryDefinition(repositoryId); registerNameSpacesAndNodeTypes(physicalWorkspaceName, repositoryDefinition, provider); }
@Override public void loadRepository(RepositoryDefinition definition) throws RepositoryNotInitializedException, InstantiationException, IllegalAccessException, ClassNotFoundException { log.info("Loading JCR {}", definition.getName()); // create also mgnlVersion and mgnlSystem for each repository. Set<String> workspaces = new LinkedHashSet<>(definition.getWorkspaces()); workspaces.addAll(Arrays.asList(RepositoryConstants.SYSTEM, RepositoryConstants.VERSION_STORE)); definition.getWorkspaces().clear(); definition.getWorkspaces().addAll(workspaces); Class<? extends Provider> providerClass = Classes.getClassFactory().forName(definition.getProvider()); Provider provider = Components.getComponentProvider().newInstance(providerClass); provider.init(definition); Repository repository = provider.getUnderlyingRepository(); workspaceMapping.setRepository(definition.getName(), repository); workspaceMapping.setRepositoryProvider(definition.getName(), provider); if (definition.isLoadOnStartup()) { for (String workspaceId : workspaces) { registerNameSpacesAndNodeTypes(workspaceId, definition, provider); } } }
@Override public Session getSystemSession(String logicalWorkspaceName) throws RepositoryException { WorkspaceMappingDefinition mapping = this.workspaceMapping.getWorkspaceMapping(logicalWorkspaceName); if (mapping == null) { throw new NoSuchWorkspaceException(logicalWorkspaceName); } Provider provider = getRepositoryProvider(mapping.getRepositoryName()); return wrapSession(provider.getSystemSession(mapping.getPhysicalWorkspaceName()), logicalWorkspaceName); }
String repoName = repoDefinition.getName(); Provider provider = workspaceMapping.getRepositoryProvider(repoName); Session session = provider.getSystemSession("default"); try { for (String wksName : session.getWorkspace().getAccessibleWorkspaceNames()) {
/** * Register nodeType file in repository. * * @param repositoryName repository name * @param nodeTypeFile nodeType file */ private void registerNodeTypeFile(String repositoryName, String nodeTypeFile) { Provider provider = repositoryManager.getRepositoryProvider(repositoryName); try { provider.registerNodeTypes(nodeTypeFile); } catch (RepositoryException e) { log.error(e.getMessage(), e); } } }
@Override protected void doExecute(InstallContext installContext) throws RepositoryException, TaskExecutionException { TypeDefinition type = new TypeDefinition(); type.setName(typeName); String nodeTypes = null; try { nodeTypes = type.getNodeTypes(); // default value if (StringUtils.isEmpty(nodeTypes)) { nodeTypes = DataModule.NODE_TYPE_DEF_TEMPLATE.format(new String[] { type.getName() }); } ContentRepository.getRepositoryProvider(DataModule.WORKSPACE).registerNodeTypes(new ByteArrayInputStream(nodeTypes.getBytes())); } catch (RepositoryException e) { log.error("Failed to register node type: {}", nodeTypes); throw new RuntimeException(e); } } }
@Override @Before public void setUp() throws Exception { super.setUp(); // Initial Context final ModuleRegistryImpl moduleRegistry = new ModuleRegistryImpl(); installContext = new InstallContextImpl(moduleRegistry); sessionConfig = installContext.getJCRSession(RepositoryConstants.CONFIG); // Register Same node type RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); repositoryManager.getRepositoryProvider("magnolia").registerNodeTypes(new ByteArrayInputStream(nodeType.getBytes())); // Create tree with sibling new PropertiesImportExport().createNodes(sessionConfig.getRootNode(), IOUtils.toInputStream(rootTree)); sessionConfig.save(); rootNode = sessionConfig.getRootNode(); }
@Override @Before public void setUp() throws Exception { super.setUp(); dataSession = MgnlContext.getJCRSession("data"); // Register node type definition RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); try { // Register the target Node type definition repositoryManager.getRepositoryProvider("magnolia").registerNodeTypes(new ByteArrayInputStream(getTargetNodeTypeDefinition().getBytes())); // Register the data node type definition repositoryManager.getRepositoryProvider("magnolia").registerNodeTypes(new ByteArrayInputStream(getDataNodeTypeDefinition().getBytes())); // Register the custom node type (this type is for example category in data) repositoryManager.getRepositoryProvider("magnolia").registerNodeTypes(new ByteArrayInputStream(getCustomNodeTypeDefinition().getBytes())); } catch (RepositoryException e) { log.error("", e); } final ModuleRegistryImpl moduleRegistry = new ModuleRegistryImpl(); installContext = new InstallContextImpl(moduleRegistry); // Init target session targetSession = MgnlContext.getJCRSession(getTargetWorkSpaceName()); // Init data node structure URL resource = ClasspathResourcesUtil.getResource(getDataNodeStructureDefinitionFileName()); new PropertiesImportExport().createNodes(dataSession.getRootNode(), resource.openStream()); dataSession.save(); // Init Components ComponentsTestUtil.setImplementation(I18nContentSupport.class, DefaultI18nContentSupport.class); }
@Test public void testAddMixin() throws Exception { final Node content = getTestNode(); final String workspaceName = content.getSession().getWorkspace().getName(); final String mixDeleted = "mgnl:deleted"; RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); String repoName = repositoryManager.getRepositoryNameForWorkspace(workspaceName); final Provider repoProvider = repositoryManager.getRepositoryProvider(repoName); final String mgnlMixDeleted = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<nodeTypes" + " xmlns:rep=\"internal\"" + " xmlns:nt=\"http://www.jcp.org/jcr/nt/1.0\"" + " xmlns:mix=\"http://www.jcp.org/jcr/mix/1.0\"" + " xmlns:mgnl=\"http://www.magnolia.info/jcr/mgnl\"" + " xmlns:jcr=\"http://www.jcp.org/jcr/1.0\">" + "<nodeType name=\"" + mixDeleted + "\" isMixin=\"true\" hasOrderableChildNodes=\"true\" primaryItemName=\"\">" + "<supertypes>" + "<supertype>nt:base</supertype>" + "</supertypes>" + "</nodeType>" + "</nodeTypes>"; try { repoProvider.registerNodeTypes(new ByteArrayInputStream(mgnlMixDeleted.getBytes())); } catch (RepositoryException e) { // ignore, either it's already registered and test will pass, or type can't be registered and test should fail } assertTrue(content.canAddMixin(mixDeleted)); content.addMixin(mixDeleted); }
@Before @Override public void setUp() throws Exception { super.setUp(); RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); repositoryManager.loadWorkspace("magnolia", FavoriteStore.WORKSPACE_NAME); repositoryManager.getRepositoryProvider("magnolia").registerNodeTypes(new ByteArrayInputStream(FAVORITE_NODE_TYPES.getBytes())); session = MgnlContext.getJCRSession(FavoriteStore.WORKSPACE_NAME); MockContext ctx = (MockContext) MgnlContext.getInstance(); final User user = mock(User.class); when(user.getName()).thenReturn(TEST_USER); ctx.setUser(user); MgnlContext.setInstance(ctx); favoriteStore = new FavoriteStore(); favoritesManager = new FavoritesManagerImpl(favoriteStore); }
@Test public void testAddMixin() throws IOException, RepositoryException { final Content content = getTestContent(); final String repoName = content.getWorkspace().getName(); final String mixDeleted = "mgnl:deleted"; final Provider repoProvider = ContentRepository.getRepositoryProvider(repoName); final String mgnlMixDeleted = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<nodeTypes" + " xmlns:rep=\"internal\"" + " xmlns:nt=\"http://www.jcp.org/jcr/nt/1.0\"" + " xmlns:mix=\"http://www.jcp.org/jcr/mix/1.0\"" + " xmlns:mgnl=\"http://www.magnolia.info/jcr/mgnl\"" + " xmlns:jcr=\"http://www.jcp.org/jcr/1.0\">" + "<nodeType name=\"" + mixDeleted + "\" isMixin=\"true\" hasOrderableChildNodes=\"true\" primaryItemName=\"\">" + "<supertypes>" + "<supertype>nt:base</supertype>" + "</supertypes>" + "</nodeType>" + "</nodeTypes>"; try { repoProvider.registerNodeTypes(new ByteArrayInputStream(mgnlMixDeleted.getBytes())); } catch (RepositoryException e) { // ignore, either it's already registered and test will pass, or type can't be registered and test should fail } assertTrue(content.getJCRNode().canAddMixin(mixDeleted)); content.addMixin(mixDeleted); }
@Override @Before public void setUp() throws Exception { super.setUp(); final RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); repositoryManager.loadWorkspace(REPOSITORY, WORKSPACE); repositoryManager.getRepositoryProvider(REPOSITORY).registerNodeTypes(getClass().getResourceAsStream(NODE_TYPES)); messageStore = new MessageStore(); error = createMessage("1", MessageType.ERROR); warning = createMessage("2", MessageType.WARNING); info = createMessage("3", MessageType.INFO); messageStore.saveMessage(USER, error); messageStore.saveMessage(USER, warning); messageStore.saveMessage(USER, info); }