/**
* Replace the existing property of a given type with a new property of a (possibly) different
* type
*
* @param existingProperty the existing prop
* @param newProperty the new prop that should replace the existing prop
*/
private void replaceProperty(
PropertyDefinition existingProperty, PropertyDefinition newProperty) {
ConfigurationDefinition configDef = existingProperty.getConfigurationDefinition();
// First take id from existing prop, and replace existing prop in the config def.
newProperty.setId(existingProperty.getId());
configDef.put(newProperty);
entityManager.remove(existingProperty);
entityManager.merge(configDef);
}
private ResourceType createResourceType() throws Exception {
ResourceType resourceType =
new ResourceType("RHQ Storage Node", "RHQStorage", ResourceCategory.SERVER, null);
ConfigurationDefinition pluginConfigurationDefinition =
new ConfigurationDefinition("config", null);
pluginConfigurationDefinition.put(
new PropertyDefinitionSimple("host", null, true, PropertySimpleType.STRING));
resourceType.setPluginConfigurationDefinition(pluginConfigurationDefinition);
getEntityManager().persist(resourceType);
return resourceType;
}
static {
DEFINITION.put(
new PropertyDefinitionSimple("topLevelString", null, true, PropertySimpleType.STRING));
DEFINITION.put(
new PropertyDefinitionSimple("topLevelPassword", null, true, PropertySimpleType.PASSWORD));
DEFINITION.put(
new PropertyDefinitionList(
"topLevelPasswordList",
null,
true,
new PropertyDefinitionSimple("listPassword", null, true, PropertySimpleType.PASSWORD)));
DEFINITION.put(
new PropertyDefinitionList(
"topLevelListOfMaps",
null,
true,
new PropertyDefinitionMap(
"mapWithPass",
null,
true,
new PropertyDefinitionSimple("username", null, true, PropertySimpleType.STRING),
new PropertyDefinitionSimple(
"password", null, true, PropertySimpleType.PASSWORD))));
CONFIGURATION.put(new PropertySimple("topLevelString", "topLevelString"));
CONFIGURATION.put(new PropertySimple("topLevelPassword", "topLevelPassword"));
CONFIGURATION.put(
new PropertyList(
"topLevelPasswordList",
new PropertySimple("listPassword", "0"),
new PropertySimple("listPassword", "1")));
CONFIGURATION.put(
new PropertyList(
"topLevelListOfMaps",
new PropertyMap(
"mapWithPass",
new PropertySimple("username", "username"),
new PropertySimple("password", "password"))));
}
public ConfigurationDefinitionUpdateReport updateConfigurationDefinition(
ConfigurationDefinition newDefinition, ConfigurationDefinition existingDefinition) {
ConfigurationDefinitionUpdateReport updateReport =
new ConfigurationDefinitionUpdateReport(existingDefinition);
/*
* handle grouped and ungrouped properties separately. for ungrouped, we don't need to care about the group, but
* for the grouped ones we need to start at group level and then look at the properties. This is done below.
*
* First look at the ungrouped ones.
*/
List<PropertyDefinition> existingPropertyDefinitions =
existingDefinition.getNonGroupedProperties();
List<PropertyDefinition> newPropertyDefinitions = newDefinition.getNonGroupedProperties();
if (existingPropertyDefinitions != null) {
for (PropertyDefinition newProperty : newPropertyDefinitions) {
PropertyDefinition existingProp = existingDefinition.get(newProperty.getName());
if (existingProp != null) {
log.debug("Updating nonGrouped property [" + existingProp + "]");
updatePropertyDefinition(existingProp, newProperty);
updateReport.addUpdatedPropertyDefinition(newProperty);
} else {
log.debug("Adding nonGrouped property [" + newProperty + "]");
existingDefinition.put(newProperty);
updateReport.addNewPropertyDefinition(newProperty);
}
}
existingDefinition =
removeNoLongerUsedProperties(
newDefinition, existingDefinition, existingPropertyDefinitions);
} else {
// TODO what if existingDefinitions is null?
// we probably don't run in here, as the initial persisting is done
// somewhere else.
}
/*
* Now update / delete contained groups We need to be careful here, as groups are present in PropertyDefinition
* as "backlink" from PropertyDefinition to group
*/
List<PropertyGroupDefinition> existingGroups = existingDefinition.getGroupDefinitions();
List<PropertyGroupDefinition> newGroups = newDefinition.getGroupDefinitions();
List<PropertyGroupDefinition> toPersist = missingInFirstList(existingGroups, newGroups);
List<PropertyGroupDefinition> toDelete = missingInFirstList(newGroups, existingGroups);
List<PropertyGroupDefinition> toUpdate = intersection(existingGroups, newGroups);
// delete groups no longer present
for (PropertyGroupDefinition group : toDelete) {
List<PropertyDefinition> groupedDefinitions =
existingDefinition.getPropertiesInGroup(group.getName());
// first look for contained stuff
for (PropertyDefinition def : groupedDefinitions) {
log.debug("Removing property [" + def + "] from group [" + group + "]");
existingPropertyDefinitions.remove(def);
existingDefinition.getPropertyDefinitions().remove(def.getName());
def.setPropertyGroupDefinition(null);
entityManager.remove(def);
}
// then remove the definition itself
log.debug("Removing group [" + group + "]");
existingGroups.remove(group);
entityManager.remove(group);
}
// update existing groups that stay
for (PropertyGroupDefinition group : toUpdate) {
String groupName = group.getName();
List<PropertyDefinition> newGroupedDefinitions =
newDefinition.getPropertiesInGroup(groupName);
for (PropertyDefinition nDef : newGroupedDefinitions) {
PropertyDefinition existingProperty =
existingDefinition.getPropertyDefinitions().get(nDef.getName());
if (existingProperty != null) {
log.debug("Updating property [" + nDef + "] in group [" + group + "]");
updatePropertyDefinition(existingProperty, nDef);
updateReport.addUpdatedPropertyDefinition(nDef);
} else {
log.debug("Adding property [" + nDef + "] to group [" + group + "]");
existingDefinition.put(nDef);
updateReport.addNewPropertyDefinition(nDef);
}
}
// delete outdated properties of this group
existingDefinition =
removeNoLongerUsedProperties(
newDefinition,
existingDefinition,
existingDefinition.getPropertiesInGroup(groupName));
}
// persist new groups
for (PropertyGroupDefinition group : toPersist) {
// First persist a new group definition and then link the properties to it
log.debug("Persisting new group [" + group + "]");
entityManager.persist(group);
existingGroups.add(group); // iterating over this does not update the underlying crap
List<PropertyDefinition> defs = newDefinition.getPropertiesInGroup(group.getName());
Map<String, PropertyDefinition> exPDefs = existingDefinition.getPropertyDefinitions();
for (PropertyDefinition def : defs) {
entityManager.persist(def);
def.setPropertyGroupDefinition(group);
def.setConfigurationDefinition(existingDefinition);
if (!exPDefs.containsKey(def.getName())) {
updateReport.addNewPropertyDefinition(def);
}
exPDefs.put(def.getName(), def);
}
}
/*
* Now work on the templates.
*/
Map<String, ConfigurationTemplate> existingTemplates = existingDefinition.getTemplates();
Map<String, ConfigurationTemplate> newTemplates = newDefinition.getTemplates();
List<String> toRemove = new ArrayList<String>();
List<String> templatesToUpdate = new ArrayList<String>();
for (String name : existingTemplates.keySet()) {
if (newTemplates.containsKey(name)) {
templatesToUpdate.add(name);
} else {
toRemove.add(name);
}
}
for (String name : toRemove) {
log.debug("Removing template [" + name + "]");
ConfigurationTemplate template = existingTemplates.remove(name);
entityManager.remove(template);
}
for (String name : templatesToUpdate) {
log.debug("Updating template [" + name + "]");
updateTemplate(existingDefinition.getTemplate(name), newTemplates.get(name));
}
for (String name : newTemplates.keySet()) {
// add completely new templates
if (!existingTemplates.containsKey(name)) {
log.debug("Adding template [" + name + "]");
ConfigurationTemplate newTemplate = newTemplates.get(name);
// we need to set a valid configurationDefinition, where we will live on.
newTemplate.setConfigurationDefinition(existingDefinition);
entityManager.persist(newTemplate);
existingTemplates.put(name, newTemplate);
}
}
return updateReport;
}
static {
INSTANCE.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
INSTANCE.put(createName(INSTANCE, false));
INSTANCE.put(createDescription(INSTANCE));
INSTANCE.put(createEnabled(INSTANCE));
INSTANCE.put(createDriftHandlingMode(INSTANCE));
INSTANCE.put(createInterval(INSTANCE));
INSTANCE.put(createBasedir(INSTANCE, false));
INSTANCE.put(createIncludes(INSTANCE, false));
INSTANCE.put(createExcludes(INSTANCE, false));
INSTANCE.put(createPinned(INSTANCE, false));
INSTANCE.put(createAttached(INSTANCE, false));
INSTANCE_FOR_EXISTING_CONFIGS.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
INSTANCE_FOR_EXISTING_CONFIGS.put(createName(INSTANCE_FOR_EXISTING_CONFIGS, true));
INSTANCE_FOR_EXISTING_CONFIGS.put(createDescription(INSTANCE_FOR_EXISTING_CONFIGS));
INSTANCE_FOR_EXISTING_CONFIGS.put(createEnabled(INSTANCE_FOR_EXISTING_CONFIGS));
INSTANCE_FOR_EXISTING_CONFIGS.put(createDriftHandlingMode(INSTANCE_FOR_EXISTING_CONFIGS));
INSTANCE_FOR_EXISTING_CONFIGS.put(createInterval(INSTANCE_FOR_EXISTING_CONFIGS));
INSTANCE_FOR_EXISTING_CONFIGS.put(createBasedir(INSTANCE_FOR_EXISTING_CONFIGS, true));
INSTANCE_FOR_EXISTING_CONFIGS.put(createIncludes(INSTANCE_FOR_EXISTING_CONFIGS, true));
INSTANCE_FOR_EXISTING_CONFIGS.put(createExcludes(INSTANCE_FOR_EXISTING_CONFIGS, true));
INSTANCE_FOR_EXISTING_CONFIGS.put(createExcludes(INSTANCE_FOR_EXISTING_CONFIGS, true));
INSTANCE_FOR_EXISTING_CONFIGS.put(createAttached(INSTANCE_FOR_EXISTING_CONFIGS, false));
INSTANCE_FOR_EXISTING_CONFIGS.put(createPinned(INSTANCE_FOR_EXISTING_CONFIGS, false));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createName(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, false));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createDescription(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createInterval(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createEnabled(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createDriftHandlingMode(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createBasedir(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createIncludes(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createExcludes(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createPinned(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createAttached(NEW_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.setConfigurationFormat(
ConfigurationFormat.STRUCTURED);
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createName(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createDescription(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createInterval(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createEnabled(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createDriftHandlingMode(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createBasedir(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createIncludes(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createExcludes(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createPinned(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE.put(
createAttached(EXISTING_RESOURCE_INSTANCE_BY_PINNED_TEMPLATE, true));
NEW_TEMPLATE_INSTANCE.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
NEW_TEMPLATE_INSTANCE.put(createName(NEW_TEMPLATE_INSTANCE, false));
NEW_TEMPLATE_INSTANCE.put(createDescription(NEW_TEMPLATE_INSTANCE));
NEW_TEMPLATE_INSTANCE.put(createInterval(NEW_TEMPLATE_INSTANCE));
NEW_TEMPLATE_INSTANCE.put(createEnabled(NEW_TEMPLATE_INSTANCE));
NEW_TEMPLATE_INSTANCE.put(createDriftHandlingMode(NEW_TEMPLATE_INSTANCE));
NEW_TEMPLATE_INSTANCE.put(createBasedir(NEW_TEMPLATE_INSTANCE, false));
NEW_TEMPLATE_INSTANCE.put(createIncludes(NEW_TEMPLATE_INSTANCE, false));
NEW_TEMPLATE_INSTANCE.put(createExcludes(NEW_TEMPLATE_INSTANCE, false));
EXISTING_TEMPLATE_INSTANCE.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
EXISTING_TEMPLATE_INSTANCE.put(createName(EXISTING_TEMPLATE_INSTANCE, true));
EXISTING_TEMPLATE_INSTANCE.put(createDescription(EXISTING_TEMPLATE_INSTANCE));
EXISTING_TEMPLATE_INSTANCE.put(createInterval(EXISTING_TEMPLATE_INSTANCE));
EXISTING_TEMPLATE_INSTANCE.put(createEnabled(EXISTING_TEMPLATE_INSTANCE));
EXISTING_TEMPLATE_INSTANCE.put(createDriftHandlingMode(EXISTING_TEMPLATE_INSTANCE));
EXISTING_TEMPLATE_INSTANCE.put(createBasedir(EXISTING_TEMPLATE_INSTANCE, true));
EXISTING_TEMPLATE_INSTANCE.put(createIncludes(EXISTING_TEMPLATE_INSTANCE, true));
EXISTING_TEMPLATE_INSTANCE.put(createExcludes(EXISTING_TEMPLATE_INSTANCE, true));
NEW_PINNED_TEMPLATE_INSTANCE.setConfigurationFormat(ConfigurationFormat.STRUCTURED);
NEW_PINNED_TEMPLATE_INSTANCE.put(createName(NEW_PINNED_TEMPLATE_INSTANCE, false));
NEW_PINNED_TEMPLATE_INSTANCE.put(createDescription(NEW_PINNED_TEMPLATE_INSTANCE));
NEW_PINNED_TEMPLATE_INSTANCE.put(createInterval(NEW_PINNED_TEMPLATE_INSTANCE));
NEW_PINNED_TEMPLATE_INSTANCE.put(createEnabled(NEW_PINNED_TEMPLATE_INSTANCE));
NEW_PINNED_TEMPLATE_INSTANCE.put(createDriftHandlingMode(NEW_PINNED_TEMPLATE_INSTANCE));
NEW_PINNED_TEMPLATE_INSTANCE.put(createBasedir(NEW_PINNED_TEMPLATE_INSTANCE, true));
NEW_PINNED_TEMPLATE_INSTANCE.put(createIncludes(NEW_PINNED_TEMPLATE_INSTANCE, true));
NEW_PINNED_TEMPLATE_INSTANCE.put(createExcludes(NEW_PINNED_TEMPLATE_INSTANCE, true));
}
/**
* This returns the metadata describing the system settings.
*
* @param config the current configuration settings from the server. Some values will be converted
* to the types the definition will expect - for example, the JAAS setting will not be "LDAP"
* or "JDBC" as the server would know it, rather the value will be "true" or "false" (i.e. is
* ldap enabled or not?)
* @param driftPlugins the set of drift server plugins that are currently deployed
* @return system settings config def
*/
private ConfigurationDefinition getSystemSettingsDefinition(
Configuration config, Map<String, String> driftPlugins) {
ConfigurationDefinition def =
new ConfigurationDefinition("sysset", MSG.view_adminConfig_systemSettings());
///////////////////////////////////
// General Configuration Properties
PropertyGroupDefinition generalGroup = new PropertyGroupDefinition("general");
generalGroup.setDisplayName(MSG.view_admin_systemSettings_group_general());
generalGroup.setDefaultHidden(false);
generalGroup.setOrder(0);
PropertyDefinitionSimple baseUrl =
new PropertyDefinitionSimple(
Constant.BaseURL,
MSG.view_admin_systemSettings_BaseURL_desc(),
true,
PropertySimpleType.STRING);
baseUrl.setDisplayName(MSG.view_admin_systemSettings_BaseURL_name());
baseUrl.setPropertyGroupDefinition(generalGroup);
baseUrl.setDefaultValue("http://localhost:7080");
def.put(baseUrl);
PropertyDefinitionSimple agentMaxQuietTimeAllowed =
new PropertyDefinitionSimple(
Constant.AgentMaxQuietTimeAllowed,
MSG.view_admin_systemSettings_AgentMaxQuietTimeAllowed_desc(),
true,
PropertySimpleType.INTEGER);
agentMaxQuietTimeAllowed.setDisplayName(
MSG.view_admin_systemSettings_AgentMaxQuietTimeAllowed_name());
agentMaxQuietTimeAllowed.setPropertyGroupDefinition(generalGroup);
agentMaxQuietTimeAllowed.addConstraints(
new IntegerRangeConstraint(
Long.valueOf(2),
null)); // don't allow less than 2m since it will cause too many false backfills
agentMaxQuietTimeAllowed.setDefaultValue("15");
def.put(agentMaxQuietTimeAllowed);
PropertyDefinitionSimple enableAgentAutoUpdate =
new PropertyDefinitionSimple(
Constant.EnableAgentAutoUpdate,
MSG.view_admin_systemSettings_EnableAgentAutoUpdate_desc(),
true,
PropertySimpleType.BOOLEAN);
enableAgentAutoUpdate.setDisplayName(
MSG.view_admin_systemSettings_EnableAgentAutoUpdate_name());
enableAgentAutoUpdate.setPropertyGroupDefinition(generalGroup);
enableAgentAutoUpdate.setDefaultValue("true");
def.put(enableAgentAutoUpdate);
PropertyDefinitionSimple enableDebugMode =
new PropertyDefinitionSimple(
Constant.EnableDebugMode,
MSG.view_admin_systemSettings_EnableDebugMode_desc(),
true,
PropertySimpleType.BOOLEAN);
enableDebugMode.setDisplayName(MSG.view_admin_systemSettings_EnableDebugMode_name());
enableDebugMode.setPropertyGroupDefinition(generalGroup);
enableDebugMode.setDefaultValue("false");
def.put(enableDebugMode);
PropertyDefinitionSimple enableExperimentalFeatures =
new PropertyDefinitionSimple(
Constant.EnableExperimentalFeatures,
MSG.view_admin_systemSettings_EnableExperimentalFeatures_desc(),
true,
PropertySimpleType.BOOLEAN);
enableExperimentalFeatures.setDisplayName(
MSG.view_admin_systemSettings_EnableExperimentalFeatures_name());
enableExperimentalFeatures.setPropertyGroupDefinition(generalGroup);
enableExperimentalFeatures.setDefaultValue("false");
def.put(enableExperimentalFeatures);
////////////////////////////////////////
// Data Manager Configuration Properties
PropertyGroupDefinition dataManagerGroup = new PropertyGroupDefinition("datamanager");
dataManagerGroup.setDisplayName(MSG.view_admin_systemSettings_group_dataMgr());
dataManagerGroup.setDefaultHidden(false);
dataManagerGroup.setOrder(1);
PropertyDefinitionSimple dataMaintenance =
new PropertyDefinitionSimple(
Constant.DataMaintenance,
MSG.view_admin_systemSettings_DataMaintenance_desc(),
true,
PropertySimpleType.INTEGER);
dataMaintenance.setDisplayName(MSG.view_admin_systemSettings_DataMaintenance_name());
dataMaintenance.setPropertyGroupDefinition(dataManagerGroup);
dataMaintenance.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
dataMaintenance.setDefaultValue("1");
def.put(dataMaintenance);
PropertyDefinitionSimple availabilityPurge =
new PropertyDefinitionSimple(
Constant.AvailabilityPurge,
MSG.view_admin_systemSettings_AvailabilityPurge_desc(),
true,
PropertySimpleType.INTEGER);
availabilityPurge.setDisplayName(MSG.view_admin_systemSettings_AvailabilityPurge_name());
availabilityPurge.setPropertyGroupDefinition(dataManagerGroup);
availabilityPurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
availabilityPurge.setDefaultValue("365");
def.put(availabilityPurge);
PropertyDefinitionSimple alertPurge =
new PropertyDefinitionSimple(
Constant.AlertPurge,
MSG.view_admin_systemSettings_AlertPurge_desc(),
true,
PropertySimpleType.INTEGER);
alertPurge.setDisplayName(MSG.view_admin_systemSettings_AlertPurge_name());
alertPurge.setPropertyGroupDefinition(dataManagerGroup);
alertPurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
alertPurge.setDefaultValue("31");
def.put(alertPurge);
PropertyDefinitionSimple traitPurge =
new PropertyDefinitionSimple(
Constant.TraitPurge,
MSG.view_admin_systemSettings_TraitPurge_desc(),
true,
PropertySimpleType.INTEGER);
traitPurge.setDisplayName(MSG.view_admin_systemSettings_TraitPurge_name());
traitPurge.setPropertyGroupDefinition(dataManagerGroup);
traitPurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
traitPurge.setDefaultValue("365");
def.put(traitPurge);
PropertyDefinitionSimple rtDataPurge =
new PropertyDefinitionSimple(
Constant.RtDataPurge,
MSG.view_admin_systemSettings_RtDataPurge_desc(),
true,
PropertySimpleType.INTEGER);
rtDataPurge.setDisplayName(MSG.view_admin_systemSettings_RtDataPurge_name());
rtDataPurge.setPropertyGroupDefinition(dataManagerGroup);
rtDataPurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
rtDataPurge.setDefaultValue("31");
def.put(rtDataPurge);
PropertyDefinitionSimple eventPurge =
new PropertyDefinitionSimple(
Constant.EventPurge,
MSG.view_admin_systemSettings_EventPurge_desc(),
true,
PropertySimpleType.INTEGER);
eventPurge.setDisplayName(MSG.view_admin_systemSettings_EventPurge_name());
eventPurge.setPropertyGroupDefinition(dataManagerGroup);
eventPurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
eventPurge.setDefaultValue("14");
def.put(eventPurge);
PropertyDefinitionSimple driftFilePurge =
new PropertyDefinitionSimple(
Constant.DriftFilePurge,
MSG.view_admin_systemSettings_DriftFilePurge_desc(),
true,
PropertySimpleType.INTEGER);
driftFilePurge.setDisplayName(MSG.view_admin_systemSettings_DriftFilePurge_name());
driftFilePurge.setPropertyGroupDefinition(dataManagerGroup);
driftFilePurge.addConstraints(new IntegerRangeConstraint(Long.valueOf(1), null));
driftFilePurge.setDefaultValue("31");
def.put(driftFilePurge);
PropertyDefinitionSimple dataReindex =
new PropertyDefinitionSimple(
Constant.DataReindex,
MSG.view_admin_systemSettings_DataReindex_desc(),
true,
PropertySimpleType.BOOLEAN);
dataReindex.setDisplayName(MSG.view_admin_systemSettings_DataReindex_name());
dataReindex.setPropertyGroupDefinition(dataManagerGroup);
dataReindex.setDefaultValue("true");
def.put(dataReindex);
//////////////////////////////////////////////
// Automatic Baseline Configuration Properties
PropertyGroupDefinition baselineGroup = new PropertyGroupDefinition("baseline");
baselineGroup.setDisplayName(MSG.view_admin_systemSettings_group_baseline());
baselineGroup.setDefaultHidden(false);
baselineGroup.setOrder(2);
PropertyDefinitionSimple baselineFrequency =
new PropertyDefinitionSimple(
Constant.BaselineFrequency,
MSG.view_admin_systemSettings_BaselineFrequency_desc(),
true,
PropertySimpleType.INTEGER);
baselineFrequency.setDisplayName(MSG.view_admin_systemSettings_BaselineFrequency_name());
baselineFrequency.setPropertyGroupDefinition(baselineGroup);
baselineFrequency.addConstraints(new IntegerRangeConstraint(Long.valueOf(0), null));
baselineFrequency.setDefaultValue("3");
def.put(baselineFrequency);
PropertyDefinitionSimple baselineDataSet =
new PropertyDefinitionSimple(
Constant.BaselineDataSet,
MSG.view_admin_systemSettings_BaselineDataSet_desc(),
true,
PropertySimpleType.INTEGER);
baselineDataSet.setDisplayName(MSG.view_admin_systemSettings_BaselineDataSet_name());
baselineDataSet.setPropertyGroupDefinition(baselineGroup);
baselineDataSet.addConstraints(
new IntegerRangeConstraint(
Long.valueOf(1),
Long.valueOf(14))); // can't do more than 14 days since our raw tables don't hold more
baselineDataSet.setDefaultValue("7");
def.put(baselineDataSet);
////////////////////////////////
// LDAP Configuration Properties
PropertyGroupDefinition ldapGroup = new PropertyGroupDefinition("ldap");
ldapGroup.setDisplayName(MSG.view_admin_systemSettings_group_ldap());
ldapGroup.setDefaultHidden(
!Boolean.parseBoolean(
config.getSimpleValue(Constant.JAASProvider, "false"))); // show if LDAP is in use
ldapGroup.setOrder(3);
PropertyDefinitionSimple jaasProvider =
new PropertyDefinitionSimple(
Constant.JAASProvider,
MSG.view_admin_systemSettings_JAASProvider_desc(),
true,
PropertySimpleType.BOOLEAN);
jaasProvider.setDisplayName(MSG.view_admin_systemSettings_JAASProvider_name());
jaasProvider.setPropertyGroupDefinition(ldapGroup);
jaasProvider.setDefaultValue("false");
def.put(jaasProvider);
PropertyDefinitionSimple ldapUrl =
new PropertyDefinitionSimple(
Constant.LDAPUrl,
MSG.view_admin_systemSettings_LDAPUrl_desc(),
true,
PropertySimpleType.STRING);
ldapUrl.setDisplayName(MSG.view_admin_systemSettings_LDAPUrl_name());
ldapUrl.setPropertyGroupDefinition(ldapGroup);
ldapUrl.setDefaultValue("ldap://localhost");
def.put(ldapUrl);
PropertyDefinitionSimple ldapProtocol =
new PropertyDefinitionSimple(
Constant.LDAPProtocol,
MSG.view_admin_systemSettings_LDAPProtocol_desc(),
true,
PropertySimpleType.BOOLEAN);
ldapProtocol.setDisplayName(MSG.view_admin_systemSettings_LDAPProtocol_name());
ldapProtocol.setPropertyGroupDefinition(ldapGroup);
ldapProtocol.setDefaultValue("false");
def.put(ldapProtocol);
PropertyDefinitionSimple ldapLoginProperty =
new PropertyDefinitionSimple(
Constant.LDAPLoginProperty,
MSG.view_admin_systemSettings_LDAPLoginProperty_desc(),
false,
PropertySimpleType.STRING);
ldapLoginProperty.setDisplayName(MSG.view_admin_systemSettings_LDAPLoginProperty_name());
ldapLoginProperty.setPropertyGroupDefinition(ldapGroup);
ldapLoginProperty.setDefaultValue("cn");
def.put(ldapLoginProperty);
PropertyDefinitionSimple ldapFilter =
new PropertyDefinitionSimple(
Constant.LDAPFilter,
MSG.view_admin_systemSettings_LDAPFilter_desc(),
false,
PropertySimpleType.STRING);
ldapFilter.setDisplayName(MSG.view_admin_systemSettings_LDAPFilter_name());
ldapFilter.setPropertyGroupDefinition(ldapGroup);
ldapFilter.setDefaultValue("");
def.put(ldapFilter);
PropertyDefinitionSimple ldapGroupFilter =
new PropertyDefinitionSimple(
Constant.LDAPGroupFilter,
MSG.view_admin_systemSettings_LDAPGroupFilter_desc(),
false,
PropertySimpleType.STRING);
ldapGroupFilter.setDisplayName(MSG.view_admin_systemSettings_LDAPGroupFilter_name());
ldapGroupFilter.setPropertyGroupDefinition(ldapGroup);
ldapGroupFilter.setDefaultValue("rhqadmin");
def.put(ldapGroupFilter);
PropertyDefinitionSimple ldapGroupMember =
new PropertyDefinitionSimple(
Constant.LDAPGroupMember,
MSG.view_admin_systemSettings_LDAPGroupMember_desc(),
false,
PropertySimpleType.STRING);
ldapGroupMember.setDisplayName(MSG.view_admin_systemSettings_LDAPGroupMember_name());
ldapGroupMember.setPropertyGroupDefinition(ldapGroup);
ldapGroupMember.setDefaultValue("");
def.put(ldapGroupMember);
PropertyDefinitionSimple ldapBaseDN =
new PropertyDefinitionSimple(
Constant.LDAPBaseDN,
MSG.view_admin_systemSettings_LDAPBaseDN_desc(),
false,
PropertySimpleType.STRING);
ldapBaseDN.setDisplayName(MSG.view_admin_systemSettings_LDAPBaseDN_name());
ldapBaseDN.setPropertyGroupDefinition(ldapGroup);
ldapBaseDN.setDefaultValue("o=RedHat,c=US");
def.put(ldapBaseDN);
PropertyDefinitionSimple ldapBindDN =
new PropertyDefinitionSimple(
Constant.LDAPBindDN,
MSG.view_admin_systemSettings_LDAPBindDN_desc(),
false,
PropertySimpleType.STRING);
ldapBindDN.setDisplayName(MSG.view_admin_systemSettings_LDAPBindDN_name());
ldapBindDN.setPropertyGroupDefinition(ldapGroup);
ldapBindDN.setDefaultValue("");
def.put(ldapBindDN);
PropertyDefinitionSimple ldapBindPW =
new PropertyDefinitionSimple(
Constant.LDAPBindPW,
MSG.view_admin_systemSettings_LDAPBindPW_desc(),
false,
PropertySimpleType.PASSWORD);
ldapBindPW.setDisplayName(MSG.view_admin_systemSettings_LDAPBindPW_name());
ldapBindPW.setPropertyGroupDefinition(ldapGroup);
ldapBindPW.setDefaultValue("");
def.put(ldapBindPW);
///////////////////////////////////////////
// Drift Server Configuration Properties //
///////////////////////////////////////////
PropertyGroupDefinition driftGroup = new PropertyGroupDefinition("drift");
driftGroup.setDisplayName(MSG.view_admin_systemSettings_group_drift());
driftGroup.setOrder(4);
driftGroup.setDefaultHidden(false);
PropertyDefinitionSimple activeDriftServer =
new PropertyDefinitionSimple(
Constant.ACTIVE_DRIFT_PLUGIN,
MSG.view_admin_systemSettings_ActiveDriftServerPlugin_desc(),
true,
PropertySimpleType.STRING);
activeDriftServer.setDisplayName(MSG.view_admin_systemSettings_ActiveDriftServerPlugin_name());
activeDriftServer.setPropertyGroupDefinition(driftGroup);
List<PropertyDefinitionEnumeration> options = new ArrayList<PropertyDefinitionEnumeration>();
for (Map.Entry<String, String> entry : driftPlugins.entrySet()) {
options.add(new PropertyDefinitionEnumeration(entry.getValue(), entry.getKey()));
}
activeDriftServer.setEnumeratedValues(options, false);
def.put(activeDriftServer);
//
// if the config is missing any properties for which we have defaults, set them to their
// defaults
//
Map<String, PropertyDefinition> allDefinitions = def.getPropertyDefinitions();
for (Map.Entry<String, PropertyDefinition> defEntry : allDefinitions.entrySet()) {
String propertyName = defEntry.getKey();
PropertyDefinition propertyDef = defEntry.getValue();
if (config.get(propertyName) == null) {
if (propertyDef instanceof PropertyDefinitionSimple
&& ((PropertyDefinitionSimple) propertyDef).getDefaultValue() != null) {
config.put(
new PropertySimple(
propertyName, ((PropertyDefinitionSimple) propertyDef).getDefaultValue()));
}
}
}
return def;
}