protected void dropRepositories() {
for (Repository repository : repositoryRegistry.getRepositories()) {
try {
repositoryRegistry.removeRepositorySilently(repository.getId());
} catch (NoSuchRepositoryException e) {
// will not happen
}
}
}
private Repository findRepository() {
try {
return repositoryRegistry.getRepository(getRepositoryId());
} catch (NoSuchRepositoryException e) {
return null;
}
}
public void writeRepositoryMetadata(
final String repositoryId, final RepositoryMetadata repositoryMetadata)
throws NoSuchRepositoryException, MetadataHandlerException, IOException {
final Repository repository = repositoryRegistry.getRepository(repositoryId);
final NexusRawTransport nrt = new NexusRawTransport(repository, true, false);
repositoryMetadataHandler.writeRepositoryMetadata(repositoryMetadata, nrt);
}
/**
* Tests walking an out of service repo. The walker should NOT not fail, but also NOT find any
* items.</BR> Verifies fix for: NEXUS-4554 (which is more general then just fixing the Trash
* task)
*/
@Test
public void testWalkOutOfServiceRepo() throws Exception {
// put repo2 out of service
String repoId = "repo2";
M2Repository repo = (M2Repository) repositoryRegistry.getRepository(repoId);
repo.setLocalStatus(LocalStatus.OUT_OF_SERVICE);
repo.commitChanges();
TestWalkerProcessor wp = null;
WalkerContext wc = null;
wp = new TestWalkerProcessor();
// this is a group
wc =
new DefaultWalkerContext(
getRepositoryRegistry().getRepository(repoId),
new ResourceStoreRequest(RepositoryItemUid.PATH_ROOT, true));
wc.getProcessors().add(wp);
walker.walk(wc);
Assert.assertEquals(0, wp.collEnters);
Assert.assertEquals(0, wp.collExits);
Assert.assertEquals(0, wp.colls);
Assert.assertEquals(0, wp.files);
Assert.assertEquals(0, wp.links);
}
protected Repository getRepositoryForPathPrefixOrId(
String pathPrefixOrId, Class<? extends Repository> kind) throws NoSuchRepositoryException {
List<? extends Repository> repositories = repositoryRegistry.getRepositoriesWithFacet(kind);
Repository idMatched = null;
Repository pathPrefixMatched = null;
for (Repository repository : repositories) {
if (StringUtils.equals(repository.getId(), pathPrefixOrId)) {
idMatched = repository;
}
if (StringUtils.equals(repository.getPathPrefix(), pathPrefixOrId)) {
pathPrefixMatched = repository;
}
}
if (idMatched != null) {
// id wins
return idMatched;
}
if (pathPrefixMatched != null) {
// if no id found, prefix wins
return pathPrefixMatched;
}
// nothing found
throw new NoSuchRepositoryException("pathPrefixOrId: '" + pathPrefixOrId + "'");
}
private void regenerateMetadataForGroups() {
if (StringUtils.isBlank(getVersion())) {
try {
final Repository repository = repositoryRegistry.getRepository(getRepositoryId());
for (GroupRepository groupRepository :
repositoryRegistry.getGroupsOfRepository(repository)) {
if (yumRegistry.isRegistered(repository.getId())) {
MergeMetadataTask.createTaskFor(nexusScheduler, groupRepository);
}
}
} catch (NoSuchRepositoryException e) {
logger.warn(
"Repository '{}' does not exist anymore. Backing out from triggering group merge for it.",
getRepositoryId());
}
}
}
protected Repository instantiateRepository(
final Configuration configuration, final CRepository repositoryModel)
throws ConfigurationException {
checkRepositoryMaxInstanceCountForCreation(repositoryModel);
// create it, will do runtime validation
Repository repository =
runtimeConfigurationBuilder.createRepositoryFromModel(configuration, repositoryModel);
// register with repoRegistry
repositoryRegistry.addRepository(repository);
// give it back
return repository;
}
private void checkForCyclicReference(
final String id, List<String> memberRepositoryIds, String path)
throws InvalidGroupingException {
if (memberRepositoryIds.contains(id)) {
throw new InvalidGroupingException(id, path);
}
for (String memberId : memberRepositoryIds) {
try {
GroupRepository group =
repoRegistry.getRepositoryWithFacet(memberId, GroupRepository.class);
checkForCyclicReference(id, group.getMemberRepositoryIds(), path + '/' + memberId);
} catch (NoSuchRepositoryException e) {
// not a group repo, just ignore
}
}
}
public List<Repository> getMemberRepositories() {
ArrayList<Repository> result = new ArrayList<Repository>();
for (String repoId : getMemberRepositoryIds()) {
try {
Repository repo = repoRegistry.getRepository(repoId);
result.add(repo);
} catch (NoSuchRepositoryException e) {
if (getLogger().isDebugEnabled()) {
this.getLogger()
.warn("Could not find repository '{}' while iterating members", repoId, e);
} else {
this.getLogger().warn("Could not find repository '{}' while iterating members", repoId);
}
// XXX throw new StorageException( e ) ;
}
}
return result;
}
@Override
public DefaultRepositoryItemUid createUid(final String uidStr)
throws IllegalArgumentException, NoSuchRepositoryException {
if (uidStr.indexOf(":") > -1) {
String[] parts = uidStr.split(":");
if (parts.length == 2) {
Repository repository = repositoryRegistry.getRepository(parts[0]);
return createUid(repository, parts[1]);
} else {
throw new IllegalArgumentException(
uidStr
+ " is malformed RepositoryItemUid! The proper format is '<repoId>:/path/to/something'.");
}
} else {
throw new IllegalArgumentException(
uidStr
+ " is malformed RepositoryItemUid! The proper format is '<repoId>:/path/to/something'.");
}
}
public void addMemberRepositoryId(String repositoryId)
throws NoSuchRepositoryException, InvalidGroupingException {
// validate THEN modify
// this will throw NoSuchRepository if needed
Repository repo = repoRegistry.getRepository(repositoryId);
// check for cycles
List<String> memberIds =
new ArrayList<String>(getExternalConfiguration(false).getMemberRepositoryIds());
memberIds.add(repo.getId());
checkForCyclicReference(getId(), memberIds, getId());
// check for compatibility
if (!repo.getRepositoryContentClass().isCompatible(getRepositoryContentClass())) {
throw new InvalidGroupingException(
getRepositoryContentClass(), repo.getRepositoryContentClass());
}
// if we are here, all is well
getExternalConfiguration(true).addMemberRepositoryId(repo.getId());
}
protected void inspect(Event<?> evt) {
if (!isNexusStarted()) {
return;
}
Repository repository = null;
if (evt instanceof RepositoryRegistryRepositoryEvent) {
repository = ((RepositoryRegistryRepositoryEvent) evt).getRepository();
} else {
repository = ((RepositoryConfigurationUpdatedEvent) evt).getRepository();
}
try {
// check registry for existence, wont be able to do much
// if doesn't exist yet
repoRegistry.getRepository(repository.getId());
inspectForTimeline(evt, repository);
} catch (NoSuchRepositoryException e) {
log.debug("Attempted to handle repository that isn't yet in registry");
}
}
public RepositoryMetadata readRepositoryMetadata(final String repositoryId)
throws NoSuchRepositoryException, MetadataHandlerException, IOException {
final Repository repository = repositoryRegistry.getRepository(repositoryId);
final NexusRawTransport nrt = new NexusRawTransport(repository, false, true);
return repositoryMetadataHandler.readRepositoryMetadata(nrt);
}
public synchronized void deleteRepository(String id)
throws NoSuchRepositoryException, IOException, ConfigurationException {
Repository repository = repositoryRegistry.getRepository(id);
// put out of service so wont be accessed any longer
repository.setLocalStatus(LocalStatus.OUT_OF_SERVICE);
// disable indexing for same purpose
repository.setIndexable(false);
repository.setSearchable(false);
// remove dependants too
// =======
// shadows
// (fail if any repo references the currently processing one)
List<ShadowRepository> shadows =
repositoryRegistry.getRepositoriesWithFacet(ShadowRepository.class);
for (Iterator<ShadowRepository> i = shadows.iterator(); i.hasNext(); ) {
ShadowRepository shadow = i.next();
if (repository.getId().equals(shadow.getMasterRepository().getId())) {
throw new RepositoryDependentException(repository, shadow);
}
}
// ======
// groups
// (correction in config only, registry DOES handle it)
// since NEXUS-1770, groups are "self maintaining"
// ===========
// pahMappings
// (correction, since registry is completely unaware of this component)
List<CPathMappingItem> pathMappings =
getConfigurationModel().getRepositoryGrouping().getPathMappings();
for (Iterator<CPathMappingItem> i = pathMappings.iterator(); i.hasNext(); ) {
CPathMappingItem item = i.next();
item.removeRepository(id);
}
// ===========
// and finally
// this cleans it properly from the registry (from reposes and repo groups)
repositoryRegistry.removeRepository(id);
List<CRepository> reposes = getConfigurationModel().getRepositories();
for (Iterator<CRepository> i = reposes.iterator(); i.hasNext(); ) {
CRepository repo = i.next();
if (repo.getId().equals(id)) {
i.remove();
saveConfiguration();
releaseRepository(repository, getConfigurationModel(), repo);
return;
}
}
throw new NoSuchRepositoryException(id);
}
public List<Repository> getMappedRepositories(
Repository repository, ResourceStoreRequest request, List<Repository> resolvedRepositories)
throws NoSuchRepositoryException {
if (!compiled) {
compile();
}
// NEXUS-2852: to make our life easier, we will work with repository IDs,
// and will fill the result with Repositories at the end
LinkedHashSet<String> reposIdSet = new LinkedHashSet<String>(resolvedRepositories.size());
for (Repository resolvedRepositorty : resolvedRepositories) {
reposIdSet.add(resolvedRepositorty.getId());
}
// for tracking what is applied
ArrayList<RepositoryPathMapping> appliedMappings = new ArrayList<RepositoryPathMapping>();
// if include found, add it to the list.
boolean firstAdd = true;
for (RepositoryPathMapping mapping : blockings) {
if (mapping.matches(repository, request)) {
if (getLogger().isDebugEnabled()) {
getLogger()
.debug(
"The request path ["
+ request.toString()
+ "] is blocked by rule "
+ mapping.toString());
}
return Collections.emptyList();
}
}
// include, if found a match
// NEXUS-2852: watch to not add multiple times same repository
// ie. you have different inclusive rules that are triggered by same request
// and contains some repositories. This is now solved using LinkedHashSet and using repo IDs.
for (RepositoryPathMapping mapping : inclusions) {
if (mapping.matches(repository, request)) {
appliedMappings.add(mapping);
if (firstAdd) {
reposIdSet.clear();
firstAdd = false;
}
// add only those that are in initial resolvedRepositories list and that are non-user
// managed
// (preserve ordering)
if (mapping.getMappedRepositories().size() == 1
&& "*".equals(mapping.getMappedRepositories().get(0))) {
for (Repository repo : resolvedRepositories) {
reposIdSet.add(repo.getId());
}
} else {
for (Repository repo : resolvedRepositories) {
if (mapping.getMappedRepositories().contains(repo.getId()) || !repo.isUserManaged()) {
reposIdSet.add(repo.getId());
}
}
}
}
}
// then, if exlude found, remove those
for (RepositoryPathMapping mapping : exclusions) {
if (mapping.matches(repository, request)) {
appliedMappings.add(mapping);
if (mapping.getMappedRepositories().size() == 1
&& "*".equals(mapping.getMappedRepositories().get(0))) {
reposIdSet.clear();
break;
}
for (String repositoryId : mapping.getMappedRepositories()) {
Repository mappedRepository = repositoryRegistry.getRepository(repositoryId);
// but only if is user managed
if (mappedRepository.isUserManaged()) {
reposIdSet.remove(mappedRepository.getId());
}
}
}
}
// store the applied mappings to request context
ArrayList<String> appliedMappingsList = new ArrayList<String>(appliedMappings.size());
for (RepositoryPathMapping mapping : appliedMappings) {
appliedMappingsList.add(mapping.toString());
}
request.addAppliedMappingsList(repository, appliedMappingsList);
// log it if needed
if (getLogger().isDebugEnabled()) {
if (appliedMappings.isEmpty()) {
getLogger().debug("No mapping exists for request path [" + request.toString() + "]");
} else {
StringBuilder sb =
new StringBuilder(
"Request for path \""
+ request.toString()
+ "\" with the initial list of processable repositories of \""
+ ResourceStoreUtils.getResourceStoreListAsString(resolvedRepositories)
+ "\" got these mappings applied:\n");
for (RepositoryPathMapping mapping : appliedMappings) {
sb.append(" * ").append(mapping.toString()).append("\n");
}
getLogger().debug(sb.toString());
if (reposIdSet.size() == 0) {
getLogger()
.debug(
"Mapping for path ["
+ request.toString()
+ "] excluded all storages from servicing the request.");
} else {
getLogger()
.debug(
"Request path for ["
+ request.toString()
+ "] is MAPPED to reposes: "
+ reposIdSet);
}
}
}
ArrayList<Repository> result = new ArrayList<Repository>(reposIdSet.size());
try {
for (String repoId : reposIdSet) {
result.add(repositoryRegistry.getRepository(repoId));
}
} catch (NoSuchRepositoryException e) {
getLogger()
.error(
"Some of the Routes contains references to non-existant repositories! Please check the following mappings: \""
+ appliedMappingsList.toString()
+ "\".");
throw e;
}
return result;
}
protected Collection<StorageItem> listVirtualPath(
ResourceStoreRequest request, RequestRoute route) throws ItemNotFoundException {
if (route.getRequestDepth() == 0) {
// 1st level
ArrayList<StorageItem> result = new ArrayList<StorageItem>();
for (RepositoryTypeDescriptor rtd :
repositoryTypeRegistry.getRegisteredRepositoryTypeDescriptors()) {
// check is there any repo registered
if (!repositoryRegistry.getRepositoriesWithFacet(rtd.getRole()).isEmpty()) {
ResourceStoreRequest req =
new ResourceStoreRequest(
ItemPathUtils.concatPaths(request.getRequestPath(), rtd.getPrefix()));
DefaultStorageCollectionItem repositories =
new DefaultStorageCollectionItem(this, req, true, false);
repositories.getItemContext().putAll(request.getRequestContext());
result.add(repositories);
}
}
return result;
} else if (route.getRequestDepth() == 1) {
// 2nd level
List<? extends Repository> repositories = null;
Class<? extends Repository> kind = null;
for (RepositoryTypeDescriptor rtd :
repositoryTypeRegistry.getRegisteredRepositoryTypeDescriptors()) {
if (route.getStrippedPrefix().startsWith("/" + rtd.getPrefix())) {
kind = rtd.getRole();
repositories = repositoryRegistry.getRepositoriesWithFacet(kind);
break;
}
}
// if no prefix matched, Item not found
if (repositories == null || repositories.isEmpty()) {
throw new ItemNotFoundException(request);
}
// filter access to the repositories
// NOTE: do this AFTER the null/empty check so we return an empty list vs. an ItemNotFound
repositories = filterAccessToRepositories(repositories);
ArrayList<StorageItem> result = new ArrayList<StorageItem>(repositories.size());
for (Repository repository : repositories) {
if (repository.isExposed() && repository.isBrowseable()) {
DefaultStorageCollectionItem repoItem = null;
ResourceStoreRequest req = null;
if (Repository.class.equals(kind)) {
req =
new ResourceStoreRequest(
ItemPathUtils.concatPaths(request.getRequestPath(), repository.getId()));
} else {
req =
new ResourceStoreRequest(
ItemPathUtils.concatPaths(
request.getRequestPath(), repository.getPathPrefix()));
}
repoItem = new DefaultStorageCollectionItem(this, req, true, false);
repoItem.getItemContext().putAll(request.getRequestContext());
result.add(repoItem);
}
}
return result;
} else {
throw new ItemNotFoundException(request);
}
}