// clean
protected RepositoryListResourceResponse listRepositories(
Request request, boolean allReposes, boolean includeGroups) throws ResourceException {
RepositoryListResourceResponse result = new RepositoryListResourceResponse();
RepositoryListResource repoRes;
Collection<Repository> repositories = getRepositoryRegistry().getRepositories();
for (Repository repository : repositories) {
// To save UI changes at the moment, not including groups in repo call
if ((allReposes || repository.isUserManaged())
&& (includeGroups
|| !repository.getRepositoryKind().isFacetAvailable(GroupRepository.class))) {
repoRes = new RepositoryListResource();
repoRes.setResourceURI(createRepositoryReference(request, repository.getId()).toString());
repoRes.setContentResourceURI(
repositoryURLBuilder.getExposedRepositoryContentUrl(repository));
repoRes.setRepoType(getRestRepoType(repository));
repoRes.setProvider(NexusCompat.getRepositoryProviderHint(repository));
repoRes.setProviderRole(NexusCompat.getRepositoryProviderRole(repository));
repoRes.setFormat(repository.getRepositoryContentClass().getId());
repoRes.setId(repository.getId());
repoRes.setName(repository.getName());
repoRes.setUserManaged(repository.isUserManaged());
repoRes.setExposed(repository.isExposed());
repoRes.setEffectiveLocalStorageUrl(repository.getLocalUrl());
if (repository.getRepositoryKind().isFacetAvailable(MavenRepository.class)) {
repoRes.setRepoPolicy(
repository.adaptToFacet(MavenRepository.class).getRepositoryPolicy().toString());
}
if (repository.getRepositoryKind().isFacetAvailable(ProxyRepository.class)) {
repoRes.setRemoteUri(repository.adaptToFacet(ProxyRepository.class).getRemoteUrl());
}
result.addData(repoRes);
}
}
return result;
}
private void inspectForTimeline(Event<?> evt, Repository repository) {
// we do not want RSS entries about boot and repo additions during boot
StringBuilder sb = new StringBuilder();
if (repository.getRepositoryKind().isFacetAvailable(GroupRepository.class)) {
sb.append(" repository group ");
} else {
sb.append(" repository ");
}
sb.append(repository.getName());
sb.append(" (ID=");
sb.append(repository.getId());
sb.append(") ");
if (repository.getRepositoryKind().isFacetAvailable(ProxyRepository.class)) {
sb.append(" as proxy repository for URL ");
sb.append(repository.adaptToFacet(ProxyRepository.class).getRemoteUrl());
} else if (repository.getRepositoryKind().isFacetAvailable(HostedRepository.class)) {
sb.append(" as hosted repository");
} else if (repository.getRepositoryKind().isFacetAvailable(ShadowRepository.class)) {
sb.append(" as ");
sb.append(repository.getClass().getName());
sb.append(" virtual repository for ");
sb.append(repository.adaptToFacet(ShadowRepository.class).getMasterRepository().getName());
sb.append(" (ID=");
sb.append(repository.adaptToFacet(ShadowRepository.class).getMasterRepository().getId());
sb.append(") ");
}
sb.append(".");
if (evt instanceof RepositoryRegistryEventAdd) {
sb.insert(0, "Registered");
} else if (evt instanceof RepositoryRegistryEventRemove) {
sb.insert(0, "Unregistered");
} else if (evt instanceof RepositoryConfigurationUpdatedEvent) {
sb.insert(0, "Updated");
}
getFeedRecorder().addSystemEvent(FeedRecorder.SYSTEM_CONFIG_ACTION, sb.toString());
}
public static String getRepositoryPolicy(Repository repository) {
if (repository.getRepositoryKind().isFacetAvailable(MavenRepository.class)) {
return repository.adaptToFacet(MavenRepository.class).getRepositoryPolicy().toString();
} else {
return null;
}
}
protected void addRepositoryDetails(
Request request, SearchNGResponse response, Repository repository) {
boolean add = true;
for (NexusNGRepositoryDetail repoDetail : response.getRepoDetails()) {
if (repoDetail.getRepositoryId().equals(repository.getId())) {
add = false;
break;
}
}
if (add) {
NexusNGRepositoryDetail repoDetail = new NexusNGRepositoryDetail();
repoDetail.setRepositoryId(repository.getId());
repoDetail.setRepositoryName(repository.getName());
repoDetail.setRepositoryURL(
createRepositoryReference(request, repository.getId()).getTargetRef().toString());
repoDetail.setRepositoryContentClass(repository.getRepositoryContentClass().getId());
repoDetail.setRepositoryKind(extractRepositoryKind(repository));
MavenRepository mavenRepo = repository.adaptToFacet(MavenRepository.class);
if (mavenRepo != null) {
repoDetail.setRepositoryPolicy(mavenRepo.getRepositoryPolicy().name());
}
response.addRepoDetail(repoDetail);
}
}
private boolean process(
SnapshotRemovalRequest request, SnapshotRemovalResult result, Repository repository) {
// only from maven repositories, stay silent for others and simply skip
if (!repository.getRepositoryContentClass().isCompatible(contentClass)) {
getLogger().debug("Skipping '" + repository.getId() + "' is not a maven 2 repository");
return false;
}
if (!repository.getLocalStatus().shouldServiceRequest()) {
getLogger().debug("Skipping '" + repository.getId() + "' the repository is out of service");
return false;
}
if (repository.getRepositoryKind().isFacetAvailable(GroupRepository.class)) {
process(request, result, repository.adaptToFacet(GroupRepository.class));
} else if (repository.getRepositoryKind().isFacetAvailable(MavenRepository.class)) {
result.addResult(
removeSnapshotsFromMavenRepository(
repository.adaptToFacet(MavenRepository.class), request));
}
return true;
}
protected MavenRepository getMavenRepository(String id) throws ResourceException {
try {
Repository repository = getRepositoryRegistry().getRepository(id);
if (!repository.getRepositoryKind().isFacetAvailable(MavenRepository.class)) {
throw new ResourceException(
Status.CLIENT_ERROR_BAD_REQUEST, "This is not a Maven repository!");
}
return repository.adaptToFacet(MavenRepository.class);
} catch (NoSuchRepositoryException e) {
throw new ResourceException(Status.CLIENT_ERROR_NOT_FOUND, e.getMessage());
}
}
@Override
protected YumRepository doRun() throws Exception {
String repositoryId = getRepositoryId();
if (!StringUtils.isEmpty(repositoryId)) {
checkState(
yumRegistry.isRegistered(repositoryId),
"Metadata regeneration can only be run on repositories that have an enabled 'Yum: Generate Metadata' capability");
Yum yum = yumRegistry.get(repositoryId);
checkState(
yum.getNexusRepository().getRepositoryKind().isFacetAvailable(HostedRepository.class),
"Metadata generation can only be run on hosted repositories");
}
setDefaults();
LOG.debug("Generating Yum-Repository for '{}' ...", getRpmDir());
try {
getRepoDir().mkdirs();
File rpmListFile = createRpmListFile();
commandLineExecutor.exec(buildCreateRepositoryCommand(rpmListFile));
if (isUseAbsoluteUrls() && StringUtils.isNotBlank(getRpmUrl())) {
replaceUrlInRepomdXml();
}
} catch (IOException e) {
LOG.warn("Yum metadata generation failed", e);
throw new IOException("Yum metadata generation failed", e);
}
// TODO dubious
Thread.sleep(100);
final Repository repository = findRepository();
if (repository != null) {
final MavenRepository mavenRepository = repository.adaptToFacet(MavenRepository.class);
if (mavenRepository != null) {
try {
routingManager.forceUpdatePrefixFile(mavenRepository);
} catch (Exception e) {
logger.warn("Could not update Whitelist for repository '{}'", mavenRepository, e);
}
}
}
regenerateMetadataForGroups();
return new YumRepositoryImpl(getRepoDir(), repositoryId, getVersion());
}
@Override
public void doApplyConfiguration(
Repository repository,
ApplicationConfiguration configuration,
CRepositoryCoreConfiguration coreConfiguration)
throws ConfigurationException {
super.doApplyConfiguration(repository, configuration, coreConfiguration);
if (repository.getRepositoryKind().isFacetAvailable(ProxyRepository.class)) {
ProxyRepository proxy = repository.adaptToFacet(ProxyRepository.class);
proxy.getItemContentValidators().put("checksum", checksumValidator);
proxy.getItemContentValidators().put("filetypevalidator", fileTypeItemContentValidator);
}
}
public boolean releaseExistsForSnapshot(Gav snapshotGav, Map<String, Object> context) {
for (Repository repository : repositoryRegistry.getRepositories()) {
// we need to filter for:
// repository that is MavenRepository and is hosted or proxy
// repository that has release policy
if (repository.getRepositoryKind().isFacetAvailable(MavenHostedRepository.class)
|| repository.getRepositoryKind().isFacetAvailable(MavenProxyRepository.class)) {
// actually, we don't care is it proxy or hosted, we only need to filter out groups and
// other
// "composite" reposes like shadows
MavenRepository mrepository = repository.adaptToFacet(MavenRepository.class);
// look in release reposes only
if (mrepository.isUserManaged()
&& RepositoryPolicy.RELEASE.equals(mrepository.getRepositoryPolicy())) {
try {
String releaseVersion = null;
// NEXUS-3148
if (snapshotGav.getBaseVersion().endsWith("-SNAPSHOT")) {
// "-SNAPSHOT" :== 9 chars
releaseVersion =
snapshotGav
.getBaseVersion()
.substring(0, snapshotGav.getBaseVersion().length() - 9);
} else {
// "SNAPSHOT" :== 8 chars
releaseVersion =
snapshotGav
.getBaseVersion()
.substring(0, snapshotGav.getBaseVersion().length() - 8);
}
Gav releaseGav =
new Gav(
snapshotGav.getGroupId(),
snapshotGav.getArtifactId(),
releaseVersion,
snapshotGav.getClassifier(),
snapshotGav.getExtension(),
null,
null,
null,
false,
null,
false,
null);
String path = mrepository.getGavCalculator().gavToPath(releaseGav);
ResourceStoreRequest req = new ResourceStoreRequest(path, true);
req.getRequestContext().putAll(context);
mrepository.retrieveItem(false, req);
return true;
} catch (ItemNotFoundException e) {
// nothing
} catch (Exception e) {
// nothing
}
}
}
}
return false;
}
/** Converting App model to REST DTO. */
public RepositoryBaseResource getRepositoryRestModel(Request request, Repository repository) {
RepositoryResource resource = null;
if (repository.getRepositoryKind().isFacetAvailable(ProxyRepository.class)) {
resource = getRepositoryProxyRestModel(repository.adaptToFacet(ProxyRepository.class));
} else if (repository.getRepositoryKind().isFacetAvailable(ShadowRepository.class)) {
return getRepositoryShadowRestModel(request, repository.adaptToFacet(ShadowRepository.class));
} else {
resource = new RepositoryResource();
}
resource.setContentResourceURI(repositoryURLBuilder.getExposedRepositoryContentUrl(repository));
resource.setProvider(NexusCompat.getRepositoryProviderHint(repository));
resource.setProviderRole(NexusCompat.getRepositoryProviderRole(repository));
resource.setFormat(repository.getRepositoryContentClass().getId());
resource.setRepoType(getRestRepoType(repository));
resource.setId(repository.getId());
resource.setName(repository.getName());
resource.setWritePolicy(repository.getWritePolicy().name());
resource.setBrowseable(repository.isBrowseable());
resource.setIndexable(repository.isSearchable());
resource.setExposed(repository.isExposed());
resource.setNotFoundCacheTTL(repository.getNotFoundCacheTimeToLive());
// TODO: remove the default local storage, this is a work around for NEXUS-1994
// the new 1.4 API doesn't store the default URL, well, it is part of the CRepo, but it is not
// exposed.
// so we can figure it out again, I think the default local Storage should be removed from the
// REST message
// which is part of the reason for not exposing it. The other part is it is not used anywhere
// except to set
// the localUrl if not already set.
// apples to apples here, man i hate this section of code!!!!
// always set to default (see AbstractRepositoryConfigurator)
String defaultLocalStorageUrl =
((CRepositoryCoreConfiguration) repository.getCurrentCoreConfiguration())
.getConfiguration(false)
.defaultLocalStorageUrl;
resource.setDefaultLocalStorageUrl(defaultLocalStorageUrl);
// if not user set (but using default), this is null, otherwise it contains user-set value
String overrideLocalStorageUrl =
((CRepositoryCoreConfiguration) repository.getCurrentCoreConfiguration())
.getConfiguration(false)
.getLocalStorage()
.getUrl();
if (StringUtils.isNotBlank(overrideLocalStorageUrl)) {
resource.setOverrideLocalStorageUrl(overrideLocalStorageUrl);
}
if (repository.getRepositoryKind().isFacetAvailable(MavenRepository.class)) {
resource.setRepoPolicy(
repository.adaptToFacet(MavenRepository.class).getRepositoryPolicy().toString());
if (repository.getRepositoryKind().isFacetAvailable(MavenProxyRepository.class)) {
resource.setChecksumPolicy(
repository.adaptToFacet(MavenProxyRepository.class).getChecksumPolicy().toString());
resource.setDownloadRemoteIndexes(
repository.adaptToFacet(MavenProxyRepository.class).isDownloadRemoteIndexes());
}
}
// as this is a required field on ui, we need this to be set for non-maven type repos
else {
resource.setRepoPolicy(RepositoryPolicy.MIXED.name());
resource.setChecksumPolicy(ChecksumPolicy.IGNORE.name());
resource.setDownloadRemoteIndexes(false);
}
return resource;
}
