/** * Adds workspace mapping, if the physical workspace doesn't exist it is added. */ public void addWorkspaceMapping(WorkspaceMappingDefinition mapping) { if (workspaceMappingDefinitions.containsKey(mapping.getLogicalWorkspaceName())) { return; } addWorkspaceMappingDefinition(mapping); RepositoryDefinition repositoryDefinition = getRepositoryDefinition(mapping.getRepositoryName()); if (!repositoryDefinition.getWorkspaces().contains(mapping.getPhysicalWorkspaceName())) { repositoryDefinition.addWorkspace(mapping.getPhysicalWorkspaceName()); } }
@Override public void createWorkspace(String repository, String logicalWorkspaceName) throws RepositoryException { for (WorkspaceMappingDefinition mapping : workspaceMapping.getWorkspaceMappings()) { Session session = getSystemSession(mapping.getLogicalWorkspaceName()); try { if (mapping.getRepositoryName().equals(repository)) { Workspace workspace = session.getWorkspace(); workspace.createWorkspace(logicalWorkspaceName); workspaceMapping.addWorkspaceMapping(new WorkspaceMappingDefinition(logicalWorkspaceName, repository, logicalWorkspaceName)); return; } } finally { session.logout(); } } throw new RepositoryException("Repository [" + repository + "] doesn't exist."); }
/** * Returns the logical workspace name given a physical workspace name. Note that this method will return the FIRST * physical workspace it finds with this name. If there are more workspaces with this name it is not defined which * is returned. * * @return the logical workspace name or if no such logical workspace exists returns the physical workspace name given as an argument * @deprecated since 4.5 - do not use. */ public static String getInternalWorkspaceName(String physicalWorkspaceName) { RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); Collection<WorkspaceMappingDefinition> repositoryNameMap = repositoryManager.getWorkspaceMappings(); for (WorkspaceMappingDefinition mappingDefinition : repositoryNameMap) { if (mappingDefinition.getPhysicalWorkspaceName().equalsIgnoreCase(physicalWorkspaceName)) { return mappingDefinition.getLogicalWorkspaceName(); } } log.error("No Repository/Workspace name mapping defined for {}", physicalWorkspaceName); return physicalWorkspaceName; }
/** * Returns magnolia specific Repository name where this workspace is registered within <Repository/>. * * Note: if more than one repository has a physical workspace by this name this method is ambigious as to which it returns * * @throws RepositoryException if no physical workspace exists by that name * @deprecated since 4.5 - do not use. */ public static String getParentRepositoryName(String physicalWorkspaceName) throws RepositoryException { RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); for (WorkspaceMappingDefinition mapping : repositoryManager.getWorkspaceMappings()) { if (physicalWorkspaceName.equalsIgnoreCase(mapping.getPhysicalWorkspaceName())) { return mapping.getRepositoryName(); } } throw new RepositoryException("No mapping found for " + physicalWorkspaceName + " repository in magnolia repositories.xml"); }
@Override public String getRepositoryNameForWorkspace(String logicalWorkspaceName) { if (hasWorkspace(logicalWorkspaceName)) { return workspaceMapping.getWorkspaceMapping(logicalWorkspaceName).getRepositoryName(); } throw new IllegalStateException("No repository known for logical workspace name " + logicalWorkspaceName); }
public void addMapping(String logicalWorkspaceName, String repositoryName, String workspaceName) { workspaceMappings.put(logicalWorkspaceName, new WorkspaceMappingDefinition(logicalWorkspaceName, repositoryName, workspaceName)); }
/** * Returns the physical workspace name given a logical workspace name. * * @returns the physical name or if the logical name doesn't exist it is returned * @deprecated since 4.5 - use {@link info.magnolia.repository.RepositoryManager#getWorkspaceMapping(String)}. */ public static String getMappedWorkspaceName(String logicalWorkspaceName) { RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); WorkspaceMappingDefinition mapping = repositoryManager.getWorkspaceMapping(logicalWorkspaceName); return mapping != null ? mapping.getPhysicalWorkspaceName() : logicalWorkspaceName; }
public void addWorkspaceMappingDefinition(WorkspaceMappingDefinition definition) { workspaceMappingDefinitions.put(definition.getLogicalWorkspaceName(), definition); }
@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); }
/** * Returns the name of the repository for a logical workspace name. * * @returns the repository name or if the logical name doesn't exist it is returned * @deprecated since 4.5 - use {@link info.magnolia.repository.RepositoryManager#getWorkspaceMapping(String)}. */ public static String getMappedRepositoryName(String logicalWorkspaceName) { RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); WorkspaceMappingDefinition mapping = repositoryManager.getWorkspaceMapping(logicalWorkspaceName); return mapping != null ? mapping.getRepositoryName() : logicalWorkspaceName; }
if (StringUtils.equals(RepositoryConstants.VERSION_STORE, definition.getLogicalWorkspaceName()) || StringUtils.equals(RepositoryConstants.VERSION_STORE, definition.getLogicalWorkspaceName())) { log.warn("Please remove {} workspace definition from the repositories.xml configuration, this workspace is created automatically for each repository thus does not need to be specified in the configuration file.", RepositoryConstants.VERSION_STORE); } else if (StringUtils.equals(RepositoryConstants.SYSTEM, definition.getLogicalWorkspaceName()) || StringUtils.equals(RepositoryConstants.SYSTEM, definition.getPhysicalWorkspaceName())) { log.warn("Please remove {} workspace definition from the repositories.xml configuration, this workspace is created automatically for each repository thus does not need to be specified in the configuration file.", RepositoryConstants.SYSTEM); } else { workspaceMappingDefinitions.put(definition.getLogicalWorkspaceName(), definition);
/** * Adds a workspace mapping. * * @deprecated since 4.5 - use {@link info.magnolia.repository.RepositoryManager#addWorkspaceMapping(info.magnolia.repository.definition.WorkspaceMappingDefinition)} directly. */ public static void addMappedRepositoryName(String logicalWorkspaceName, String repositoryName, String workspaceName) { if (StringUtils.isEmpty(workspaceName)) { workspaceName = logicalWorkspaceName; } Components.getComponent(RepositoryManager.class).addWorkspaceMapping(new WorkspaceMappingDefinition(logicalWorkspaceName, repositoryName, workspaceName)); }
private void clone(Node node, Node parent) throws RepositoryException { if (node.getDefinition().isAutoCreated()) { Node destination = parent.getNode(node.getName()); this.removeProperties(destination); this.updateProperties(node, destination); } else { final String parentPath = parent.getPath(); final String srcWorkspaceLogicalName = node.getSession().getWorkspace().getName(); final String srcWorkspacePhysicalName = repositoryManager.getWorkspaceMapping(srcWorkspaceLogicalName).getPhysicalWorkspaceName(); final Workspace targetWorkspace = parent.getSession().getWorkspace(); final String srcPath = node.getPath(); final String targetPath = parentPath + (parentPath != null && parentPath.endsWith("/") ? "" : "/") + node.getName(); log.debug("workspace level clone from {}:{} to {}:{}", srcWorkspaceLogicalName, srcPath, targetWorkspace.getName(), parentPath); targetWorkspace.clone(srcWorkspacePhysicalName, srcPath, targetPath, true); } }
assertEquals("website", mapping1.getLogicalWorkspaceName()); assertEquals("magnolia", mapping1.getRepositoryName()); assertEquals("website", mapping1.getPhysicalWorkspaceName()); assertEquals("data", mapping2.getLogicalWorkspaceName()); assertEquals("anotherRepository", mapping2.getRepositoryName()); assertEquals("physicalName", mapping2.getPhysicalWorkspaceName()); assertEquals("config", mapping3.getLogicalWorkspaceName()); assertEquals("magnolia", mapping3.getRepositoryName()); assertEquals("config", mapping3.getPhysicalWorkspaceName());
@Override public Session getSession(String logicalWorkspaceName, Credentials credentials) throws RepositoryException { WorkspaceMappingDefinition mapping = this.workspaceMapping.getWorkspaceMapping(logicalWorkspaceName); if (mapping == null) throw new NoSuchWorkspaceException(logicalWorkspaceName); Repository repository = getRepository(mapping.getRepositoryName()); String physicalWorkspaceName = mapping.getPhysicalWorkspaceName(); Session session = repository.login(credentials, physicalWorkspaceName); return wrapSession(session, logicalWorkspaceName); }
/** * Returns the repository definition for a repository or the repository for a given workspace. */ // method copied 1-to-1 from former ContentRepository#getRepositoryMapping // TODO: ditch the terminology mix-up between former repositories and workspaces for good private info.magnolia.repository.definition.RepositoryDefinition getRepositoryMapping(String repositoryOrLogicalWorkspace) { if (!repositoryManager.hasRepository(repositoryOrLogicalWorkspace)) { WorkspaceMappingDefinition mapping = repositoryManager.getWorkspaceMapping(repositoryOrLogicalWorkspace); repositoryOrLogicalWorkspace = mapping != null ? mapping.getRepositoryName() : repositoryOrLogicalWorkspace; } return repositoryManager.getRepositoryDefinition(repositoryOrLogicalWorkspace); }
@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 Session createSession(Credentials credentials) { RepositoryManager repositoryManager = Components.getComponent(RepositoryManager.class); WorkspaceMappingDefinition mapping = repositoryManager.getWorkspaceMapping(physicalWorkspaceName); String mappedWorkspaceName = mapping != null ? mapping.getPhysicalWorkspaceName() : physicalWorkspaceName; Session session; try { session = repository.login(credentials, mappedWorkspaceName); } catch (RepositoryException e) { throw new RuntimeRepositoryException(e); } return session; } }
@Test public void repositoryIsClusteredAndClusterMaster() throws Exception { // GIVEN MagnoliaConfigurationProperties properties = mock(MagnoliaConfigurationProperties.class); given(properties.getProperty(MagnoliaConfigurationProperties.MAGNOLIA_REPOSITORIES_CLUSTER_CONFIG)).willReturn("website"); given(properties.getBooleanProperty(MagnoliaConfigurationProperties.MAGNOLIA_REPOSITORIES_CLUSTER_MASTER)).willReturn(true); given(properties.hasProperty(MagnoliaConfigurationProperties.MAGNOLIA_REPOSITORIES_CLUSTER_MASTER)).willReturn(true); WorkspaceMapping workspaceMapping = new WorkspaceMapping(); RepositoryDefinition repositoryDefinition = mock(RepositoryDefinition.class); Map<String, String> definitionMap = newHashMap(); definitionMap.put("website", "website"); definitionMap.put("null-mgnlVersion", "mgnlVersion"); given(repositoryDefinition.getName()).willReturn("magnolia"); given(repositoryDefinition.getParameters()).willReturn(definitionMap); given(repositoryDefinition.getWorkspaces()).willReturn(newArrayList("website", "mgnlVersion")); workspaceMapping.addRepositoryDefinition(repositoryDefinition); workspaceMapping.addWorkspaceMapping(new WorkspaceMappingDefinition("magnolia-mgnlVersion", "magnolia", "mgnlVersion")); workspaceMapping.addWorkspaceMapping(new WorkspaceMappingDefinition("website", "magnolia", "website")); DefaultRepositoryManager repositoryManager = new DefaultRepositoryManager(properties, workspaceMapping); ComponentsTestUtil.setInstance(RepositoryManager.class, repositoryManager); // WHEN ModuleManagerImpl moduleManager = new TestModuleManagerImpl(moduleVersionHandlers, context, moduleDefinitionReader, moduleRegistry, repositoryManager); moduleManager.applyDeltas(moduleDefinition, newArrayList(delta), context); // THEN assertThat(websiteSession.hasPendingChanges(), is(false)); }