protected void validate(CPathMappingItem pathItem) throws InvalidConfigurationException {
ValidationResponse response =
this.validator.validateGroupsSettingPathMappingItem(null, pathItem);
if (!response.isValid()) {
throw new InvalidConfigurationException(response);
}
}
public void updateCatalogEntry(String catalogId, String entryId, CCatalogEntry entry)
throws InvalidConfigurationException {
ValidationResponse vr = validator.validateCatalogEntry(entry);
if (vr.getValidationErrors().size() > 0) {
throw new InvalidConfigurationException(vr);
}
lock.lock();
try {
CCatalog catalog = getCatalog(catalogId);
CCatalogEntry current = getCatalogEntry(catalogId, entryId);
if (current != null) {
catalog.getEntries().remove(current);
catalog.getEntries().add(entry);
save();
}
} finally {
lock.unlock();
}
}
public ValidationResponse validate(final CCapability capability, final boolean isCreateMode) {
final ValidationResponse response = new ValidationResponse();
if (!isCreateMode && StringUtils.isEmpty(capability.getId())) {
final ValidationMessage msg = new ValidationMessage("id", "Capability ID cannot be empty.");
response.addValidationError(msg);
}
if (StringUtils.isEmpty(capability.getName())) {
final ValidationMessage msg =
new ValidationMessage("name", "Capability name cannot be empty.");
response.addValidationError(msg);
}
if (StringUtils.isEmpty(capability.getTypeId())) {
final ValidationMessage msg =
new ValidationMessage("typeId", "Capability type cannot be empty.");
response.addValidationError(msg);
}
for (final CCapabilityProperty property : capability.getProperties()) {
if (StringUtils.isEmpty(property.getKey())) {
final ValidationMessage msg =
new ValidationMessage("type", "Capability properties cannot cannot have an empty key.");
response.addValidationError(msg);
break;
}
}
return response;
}
@Test
public void testBad2() throws Exception {
// get start with the default config
this.copyDefaultConfigToPlace();
this.copyResource("/META-INF/nexus/default-oss-nexus.xml", getNexusConfiguration());
Configuration config = this.loadNexusConfig(new File(this.getNexusConfiguration()));
// make it bad
// invalid policy
CRepository invalidPolicyRepo = config.getRepositories().get(0);
Xpp3Dom externalConfig = (Xpp3Dom) invalidPolicyRepo.getExternalConfiguration();
ExternalConfigUtil.setNodeValue(externalConfig, "repositoryPolicy", "badPolicy");
// duplicate the repository id
for (CRepository repo : config.getRepositories()) {
if (!repo.getId().equals("central")) {
// duplicate
repo.setId("central");
break;
}
}
// TODO: add more errors here
// now validate it
ValidationResponse response = underTest.validateModel(new ValidationRequest(config));
assertThat(response.isValid(), is(false));
assertThat(response.isModified(), is(false));
assertThat(response.getValidationErrors(), hasSize(greaterThan(0)));
assertThat(response.getValidationWarnings(), hasSize(0));
}
public ValidationResponse validateAnonymousUsername(
SecurityValidationContext context, String anonymousUsername) {
// we are not currently doing anything here
ValidationResponse validationResponse = new ValidationResponse();
validationResponse.setContext(context);
return validationResponse;
}
public void validateTime(String key, Date date) throws InvalidConfigurationException {
if (date.before(new Date())) {
ValidationResponse vr = new ApplicationValidationResponse();
ValidationMessage vm = new ValidationMessage(key, "Time cannot be in the past.");
vr.addValidationError(vm);
throw new InvalidConfigurationException(vr);
}
}
protected void validateRepository(CRepository settings, boolean create)
throws ConfigurationException {
ApplicationValidationContext ctx = getRepositoryValidationContext();
if (!create && !StringUtils.isEmpty(settings.getId())) {
// remove "itself" from the list to avoid hitting "duplicate repo" problem
ctx.getExistingRepositoryIds().remove(settings.getId());
}
ValidationResponse vr = configurationValidator.validateRepository(ctx, settings);
if (!vr.isValid()) {
throw new InvalidConfigurationException(vr);
}
}
public ValidationResponse validateModel(
SecurityValidationContext context, ValidationRequest<SecurityConfiguration> request) {
ValidationResponse validationResponse = new ValidationResponse();
validationResponse.setContext(context);
SecurityConfiguration configuration = request.getConfiguration();
validationResponse.append(
this.validateAnonymousUsername(context, configuration.getAnonymousUsername()));
validationResponse.append(
this.validateAnonymousPassword(context, configuration.getAnonymousPassword()));
validationResponse.append(this.validateRealms(context, configuration.getRealms()));
return validationResponse;
}
public ValidationResponse validateRealms(SecurityValidationContext context, List<String> realms) {
ValidationResponse validationResponse = new ValidationResponse();
validationResponse.setContext(context);
if ((context.getSecurityConfiguration() != null
&& context.getSecurityConfiguration().isEnabled())
|| context.getSecurityConfiguration() == null) {
if (realms.size() < 1) {
validationResponse.addValidationError(
"Security is enabled, You must have at least one realm enabled.");
}
// TODO: we should also try to load each one to see if it exists
}
return validationResponse;
}
public void createCatalog(CCatalog catalog) throws InvalidConfigurationException {
lock.lock();
try {
ValidationResponse vr = validator.validateCatalog(catalog);
if (vr.getValidationErrors().size() > 0) {
throw new InvalidConfigurationException(vr);
}
getConfiguration().getCatalogs().add(catalog);
save();
} finally {
lock.unlock();
}
}
@Test
public void testNexus1710Good() throws Exception {
// this is after fix: groupId is appended by "-group" to resolve clash
ValidationResponse response =
underTest.validateModel(
new ValidationRequest(
getConfigurationFromStream(
getClass()
.getResourceAsStream(
"/org/sonatype/nexus/configuration/upgrade/nexus1710/nexus.xml.result"))));
assertThat(response.isValid(), is(true));
assertThat(response.isModified(), is(false));
assertThat(response.getValidationErrors(), hasSize(0));
assertThat(response.getValidationWarnings(), hasSize(0));
}
public void validateStartDate(String date) throws InvalidConfigurationException {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date(Long.parseLong(date)));
Calendar nowCal = Calendar.getInstance();
nowCal.setTime(new Date());
// This is checking just the year/month/day, time isn't of concern right now
if (cal.before(nowCal)
&& (cal.get(Calendar.YEAR) != nowCal.get(Calendar.YEAR)
|| cal.get(Calendar.MONTH) != nowCal.get(Calendar.MONTH)
|| cal.get(Calendar.DAY_OF_YEAR) != nowCal.get(Calendar.DAY_OF_YEAR))) {
ValidationResponse vr = new ApplicationValidationResponse();
ValidationMessage vm = new ValidationMessage("startDate", "Date cannot be in the past.");
vr.addValidationError(vm);
throw new InvalidConfigurationException(vr);
}
}
@SuppressWarnings("unchecked")
public ValidationResponse validateModel(final ValidationRequest request) {
final ValidationResponse response = new ValidationResponse();
final Configuration configuration = (Configuration) request.getConfiguration();
if (configuration == null) {
final ValidationMessage msg =
new ValidationMessage("*", "No configuration available to validate");
response.addValidationError(msg);
} else {
for (final CCapability capability : configuration.getCapabilities()) {
response.append(validate(capability, false));
}
}
return response;
}
public synchronized void saveConfiguration() throws IOException {
if (applyConfiguration()) {
// TODO: when NEXUS-2215 is fixed, this should be remove/moved/cleaned
// START <<<
// validate before we do anything
ValidationRequest request = new ValidationRequest(configurationSource.getConfiguration());
ValidationResponse response = configurationValidator.validateModel(request);
if (!response.isValid()) {
this.getLogger()
.error("Saving nexus configuration caused unexpected error:\n" + response.toString());
throw new IOException(
"Saving nexus configuration caused unexpected error:\n" + response.toString());
}
// END <<<
configurationSource.storeConfiguration();
// we successfully saved config
eventBus.post(new ConfigurationSaveEvent(this));
}
}
public void addCatalogEntry(String catalogId, CCatalogEntry catalogEntry)
throws InvalidConfigurationException {
CCatalog catalog = readCatalog(catalogId);
catalogEntry.setId(idGenerator.generateId());
ValidationResponse vr = validator.validateCatalogEntry(catalogEntry);
if (vr.getValidationErrors().size() > 0) {
throw new InvalidConfigurationException(vr);
}
lock.lock();
try {
catalog.addEntry(catalogEntry);
save();
} finally {
lock.unlock();
}
}
/**
* A method to append a validation response to this validation response. The errors list and
* warnings list are simply appended, and the isValid is logically AND-ed and isModified is
* logically OR-ed.
*/
public void append(ValidationResponse validationResponse) {
for (ValidationMessage msg : validationResponse.getValidationErrors()) {
if (getValidationError(msg.getKey()) != null) {
msg.setKey(msg.getKey() + "(" + key++ + ")");
}
addValidationError(msg);
}
for (ValidationMessage msg : validationResponse.getValidationWarnings()) {
if (getValidationWarning(msg.getKey()) != null) {
msg.setKey(msg.getKey() + "(" + key++ + ")");
}
addValidationWarning(msg);
}
setValid(isValid() && validationResponse.isValid());
setModified(isModified() || validationResponse.isModified());
}
public void createOrUpdateCatalog(CCatalog catalog) throws InvalidConfigurationException {
ValidationResponse vr = validator.validateCatalog(catalog);
if (vr.getValidationErrors().size() > 0) {
throw new InvalidConfigurationException(vr);
}
lock.lock();
try {
CCatalog current = getCatalog(catalog.getId());
if (current != null) {
getConfiguration().getCatalogs().remove(current);
}
getConfiguration().getCatalogs().add(catalog);
save();
} finally {
lock.unlock();
}
}
@Test
public void testBad1() throws Exception {
// get start with the default config
this.copyDefaultConfigToPlace();
Configuration config = this.loadNexusConfig(new File(this.getNexusConfiguration()));
// make it bad
// remove the name from a repository
CRepository missingNameRepo = (CRepository) config.getRepositories().get(0);
missingNameRepo.setName(null);
// TDOD add 2 more warnings
// wrong shadow type
CRepository badShadow = new DefaultCRepository();
badShadow.setId("badShadow");
badShadow.setName("Does not follow");
badShadow.setProviderRole(ShadowRepository.class.getName());
badShadow.setProviderHint("m2-m1-shadow");
// Manipulate the dom
Xpp3Dom externalConfig = new Xpp3Dom("externalConfiguration");
badShadow.setExternalConfiguration(externalConfig);
ExternalConfigUtil.setNodeValue(externalConfig, "masterRepositoryId", "non-existent");
config.addRepository(badShadow);
// now validate it
ValidationResponse response = underTest.validateModel(new ValidationRequest(config));
assertThat(response.getValidationWarnings(), hasSize(1));
assertThat(response.getValidationErrors(), hasSize(0));
// codehaus-snapshots has no name, it will be defaulted
assertThat(response.isModified(), is(true));
assertThat(response.isValid(), is(true));
}
@Test
public void testNexus1710Bad() throws Exception {
// this one is easy because you can compare:
// /org/sonatype/nexus/configuration/upgrade/nexus1710/nexus.xml.result-bad
// with
// /org/sonatype/nexus/configuration/upgrade/nexus1710/nexus.xml.result
// and you have the diff, and you already have to manually update the good one.
// this was before fix: groupId/repoId name clash
ValidationResponse response =
underTest.validateModel(
new ValidationRequest(
getConfigurationFromStream(
getClass()
.getResourceAsStream(
"/org/sonatype/nexus/configuration/upgrade/nexus1710/nexus.xml.result-bad"))));
assertThat(response.isValid(), is(false));
assertThat(response.isModified(), is(false));
assertThat(response.getValidationErrors(), hasSize(1));
assertThat(response.getValidationWarnings(), hasSize(0));
}
@Test
public void repoEmptyId() {
ApplicationValidationContext ctx = new ApplicationValidationContext();
CRepository repo = new CRepository();
repo.setLocalStatus(LocalStatus.IN_SERVICE.toString());
repo.setName("name");
ValidationResponse response = underTest.validateRepository(ctx, repo);
assertThat(response.isValid(), is(false));
assertThat(response.isModified(), is(false));
assertThat(response.getValidationErrors(), hasSize(1));
assertThat(response.getValidationWarnings(), hasSize(0));
assertThat(response.getValidationErrors().get(0), hasKey("id"));
}
public Configuration loadConfiguration() throws ConfigurationException, IOException {
// propagate call and fill in defaults too
nexusDefaults.loadConfiguration();
if (getConfigurationFile() == null || getConfigurationFile().getAbsolutePath().contains("${")) {
throw new ConfigurationException(
"The configuration file is not set or resolved properly: "
+ getConfigurationFile().getAbsolutePath());
}
if (!getConfigurationFile().exists()) {
getLogger()
.warn("No configuration file in place, copying the default one and continuing with it.");
// get the defaults and stick it to place
setConfiguration(nexusDefaults.getConfiguration());
saveConfiguration(getConfigurationFile());
configurationDefaulted = true;
} else {
configurationDefaulted = false;
}
try {
loadConfiguration(getConfigurationFile());
// was able to load configuration w/o upgrading it
setConfigurationUpgraded(false);
} catch (ConfigurationException e) {
getLogger().info("Configuration file is invalid, attempting upgrade");
upgradeConfiguration(getConfigurationFile());
// had to upgrade configuration before I was able to load it
setConfigurationUpgraded(true);
loadConfiguration(getConfigurationFile());
// if the configuration is upgraded we need to reload the security.
// it would be great if this was put somewhere else, but I am out of ideas.
// the problem is the default security was already loaded with the security-system component
// was loaded
// so it has the defaults, the upgrade from 1.0.8 -> 1.4 moves security out of the nexus.xml
// and we cannot use the 'correct' way of updating the info, because that would cause an
// infinit loop
// loading the nexus.xml
this.eventMulticaster.notifyEventListeners(new SecurityConfigurationChangedEvent(null));
}
upgradeNexusVersion();
ValidationResponse vResponse =
getConfigurationValidator().validateModel(new ValidationRequest(getConfiguration()));
setValidationResponse(vResponse);
if (vResponse.isValid()) {
if (vResponse.isModified()) {
getLogger().info("Validation has modified the configuration, storing the changes.");
storeConfiguration();
}
return getConfiguration();
} else {
throw new InvalidConfigurationException(vResponse);
}
}