@Override public Collection<Repository> getAllRepositories(final Space space) { return configuredRepositories.getAllConfiguredRepositories(space); }
@Override public Repository getRepositoryFromSpace(final Space space, final String alias) { return configuredRepositories.getRepositoryByRepositoryAlias(space, alias); }
@Override public Repository getRepository(final Space space, final Path root) { return configuredRepositories.getRepositoryByRootPath(space, root); }
@Test public void testRemoveMultiBranch() throws Exception { final Path devRoot = configuredRepositories.getRepositoryByRepositoryAlias("multibranch").getBranchRoot("dev"); assertNotNull(configuredRepositories.getRepositoryByRootPath(devRoot)); assertNotNull(configuredRepositories.remove("multibranch")); assertFalse(configuredRepositories.containsAlias("multibranch")); assertNull(configuredRepositories.getRepositoryByRootPath(devRoot)); }
@Test public void testNewBranch() throws Exception { final Path branchPath = mock(Path.class); final NewBranchEvent changedEvent = new NewBranchEvent("single", "mybranch", branchPath, System.currentTimeMillis()); configuredRepositories.onNewBranch(changedEvent); // Root for both is the default root assertEquals(configuredRepositories.getRepositoryByRepositoryAlias("single").getRoot(), configuredRepositories.getRepositoryByRootPath(branchPath).getRoot()); final Repository single = configuredRepositories.getRepositoryByRepositoryAlias("single"); assertEquals(2, single.getBranches().size()); assertEquals(branchPath, single.getBranchRoot("mybranch")); } }
private void doRemoveRepository(final OrganizationalUnit orgUnit, final String alias, final ConfigGroup thisRepositoryConfig, final Consumer<Repository> notification) throws Exception { if (thisRepositoryConfig != null) { configurationService.removeConfiguration(thisRepositoryConfig); } final Repository repo = configuredRepositories.remove(orgUnit.getSpace(), alias); if (repo != null) { notification.accept(repo); Branch defaultBranch = repo.getDefaultBranch().orElseThrow(() -> new IllegalStateException("Repository should have at least one branch.")); ioService.delete(convert(defaultBranch.getPath()).getFileSystem().getPath(null)); } //Remove reference to Repository from Organizational Units for (Repository repository : orgUnit.getRepositories()) { if (repository.getAlias().equals(alias)) { organizationalUnitService.removeRepository(orgUnit, repository); metadataStore.delete(alias); } } }
final RepositoryEnvironmentConfigurations repositoryEnvironmentConfigurations) { if (configuredRepositories.containsAlias(alias)) { throw new RepositoryAlreadyExistsException(alias);
Repository getEventRepository(SocialActivitiesEvent event) { final Path path = Paths.get(event.getLinkTarget()); final FileSystem fileSystem = path.getFileSystem(); return configuredRepositories.getRepositoryByRepositoryFileSystem(fileSystem); }
private void fireNewBranchEvent(final Path targetRoot, final org.uberfire.java.nio.file.Path nioTargetRepositoryRoot) { configuredRepositories.reloadRepositories(); final Repository repository = repositoryService.getRepository(targetRoot); final Optional<Branch> branch = repository.getBranch(Paths.convert(nioTargetRepositoryRoot.getRoot())); if (branch.isPresent()) { newBranchEventEvent.fire(new NewBranchEvent(repository, branch.get().getName(), sessionInfo.getIdentity())); } else { throw new IllegalStateException("Could not find a branch that was just created. The Path used was " + nioTargetRepositoryRoot.getRoot()); } }
public void update(final Repository updatedRepo) { add(updatedRepo); }
@Before public void setUp() throws Exception { final ArrayList<ConfigGroup> configGroups = new ArrayList<>(); configGroups.add(addRepository("single", "master")); configGroups.add(addRepository("multibranch", "master", "dev", "release")); when(configurationService.getConfiguration(REPOSITORY)).thenReturn(configGroups); configuredRepositories = new ConfiguredRepositories(configurationService, repositoryFactory, SystemRepository.SYSTEM_REPO); configuredRepositories.loadRepositories(); }
@Override public void removeBranch(final WorkspaceProject project, final Branch branch) { final org.uberfire.java.nio.file.Path branchPath = pathUtil.convert(branch.getPath()); ioService.delete(branchPath); configuredRepositories.refreshRepository(project.getRepository()); }
public void flush(final @Observes @org.guvnor.structure.backend.config.Repository SystemRepositoryChangedEvent changedEvent) { loadRepositories(); } }
@Test public void testRemoveSingle() throws Exception { final Path root = configuredRepositories.getRepositoryByRepositoryAlias("single").getRoot(); assertNotNull(configuredRepositories.getRepositoryByRootPath(root)); assertNotNull(configuredRepositories.remove("single")); assertFalse(configuredRepositories.containsAlias("single")); assertNull(configuredRepositories.getRepositoryByRootPath(root)); }
final Repository repo = configuredRepositories.remove(alias); if (repo != null) { repositoryRemovedEvent.fire(new RepositoryRemovedEvent(repo));
final Collection<Contributor> contributors) { if (configuredRepositories.containsAlias(space, alias)) { throw new RepositoryAlreadyExistsException(alias);
Repository getInboxEntryRepository( InboxEntry inboxEntry ) { try { final Path path = Paths.get( inboxEntry.getItemPath() ); final FileSystem fileSystem = path.getFileSystem(); return configuredRepositories.getRepositoryByRepositoryFileSystem( fileSystem ); } catch ( FileSystemNotFoundException exception ) { return null; } }
private void fireNewBranchEvent(final Space space, final Path targetRoot, final org.uberfire.java.nio.file.Path nioTargetRepositoryRoot) { configuredRepositories.reloadRepositories(); final Repository repository = repositoryService.getRepository(space, targetRoot); final Optional<Branch> branch = repository.getBranch(Paths.convert(nioTargetRepositoryRoot.getRoot())); if (branch.isPresent()) { newBranchEventEvent.fire(new NewBranchEvent(repository, branch.get().getName(), sessionInfo.getIdentity())); } else { throw new IllegalStateException("Could not find a branch that was just created. The Path used was " + nioTargetRepositoryRoot.getRoot()); } }
@SuppressWarnings("unchecked") @PostConstruct public void loadRepositories() { repositoriesByAlias.clear(); repositoriesByBranchRoot.clear(); final List<ConfigGroup> repoConfigs = configurationService.getConfiguration(REPOSITORY); if (!(repoConfigs == null || repoConfigs.isEmpty())) { for (final ConfigGroup configGroup : repoConfigs) { final Repository repository = repositoryFactory.newRepository(configGroup); add(repository); } } }
@Test public void removeBranchTest() { final Branch masterBranch = makeBranch("master", "repo1"); final org.uberfire.java.nio.file.Path baseBranchPath = mock(org.uberfire.java.nio.file.Path.class); final FileSystem fileSystem = mock(FileSystem.class); final FileSystemProvider fileSystemProvider = mock(FileSystemProvider.class); doReturn(fileSystemProvider).when(fileSystem).provider(); doReturn(fileSystem).when(baseBranchPath).getFileSystem(); doReturn(baseBranchPath).when(pathUtil).convert(masterBranch.getPath()); final WorkspaceProject project = mock(WorkspaceProject.class); doReturn(repo1).when(project).getRepository(); libraryService.removeBranch(project, masterBranch); verify(ioService).delete(baseBranchPath); verify(configuredRepositories).refreshRepository(repo1); }