/** Parse and populate child configuration modules. */
private void populateConfigurationModules() {
ConfigurationDirectory configDirectory =
serviceDirectory.getConfigurationDirectory(serviceInfo.getConfigDir());
if (configDirectory != null) {
for (ConfigurationModule config : configDirectory.getConfigurationModules()) {
ConfigurationInfo info = config.getModuleInfo();
if (isValid()) {
setValid(config.isValid() && info.isValid());
if (!isValid()) {
setErrors(config.getErrors());
setErrors(info.getErrors());
}
}
serviceInfo.getProperties().addAll(info.getProperties());
serviceInfo.setTypeAttributes(config.getConfigType(), info.getAttributes());
configurationModules.put(config.getConfigType(), config);
}
for (String excludedType : serviceInfo.getExcludedConfigTypes()) {
if (!configurationModules.containsKey(excludedType)) {
ConfigurationInfo configInfo =
new ConfigurationInfo(
Collections.<PropertyInfo>emptyList(), Collections.<String, String>emptyMap());
ConfigurationModule config = new ConfigurationModule(excludedType, configInfo);
config.setDeleted(true);
configurationModules.put(excludedType, config);
}
}
}
}
/**
* Merges service properties from parent into the the service properties of this this service.
* Current properties overrides properties with same name from parent
*
* @param other service properties to merge with the current service property list
*/
private void mergeServiceProperties(List<ServicePropertyInfo> other) {
if (!other.isEmpty()) {
List<ServicePropertyInfo> servicePropertyList = serviceInfo.getServicePropertyList();
List<ServicePropertyInfo> servicePropertiesToAdd = Lists.newArrayList();
Set<String> servicePropertyNames =
Sets.newTreeSet(
Iterables.transform(
servicePropertyList,
new Function<ServicePropertyInfo, String>() {
@Nullable
@Override
public String apply(ServicePropertyInfo serviceProperty) {
return serviceProperty.getName();
}
}));
for (ServicePropertyInfo otherServiceProperty : other) {
if (!servicePropertyNames.contains(otherServiceProperty.getName()))
servicePropertiesToAdd.add(otherServiceProperty);
}
List<ServicePropertyInfo> mergedServicePropertyList =
ImmutableList.<ServicePropertyInfo>builder()
.addAll(servicePropertyList)
.addAll(servicePropertiesToAdd)
.build();
serviceInfo.setServicePropertyList(mergedServicePropertyList);
validateServiceInfo();
}
}
private ServiceModule createServiceModule(
ServiceInfo serviceInfo, Collection<ConfigurationModule> configurations) {
String serviceName = serviceInfo.getName();
if (serviceInfo.getName() == null) {
serviceInfo.setName("service1");
}
return createServiceModule(serviceInfo, configurations, createStackContext(serviceName, true));
}
@Test
public void testResolve_RequiredServices() throws Exception {
List<String> requiredServices = new ArrayList<String>();
requiredServices.add("foo");
requiredServices.add("bar");
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setRequiredServices(requiredServices);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(requiredServices, service.getModuleInfo().getRequiredServices());
// specified in parent only
info.setRequiredServices(null);
parentInfo.setRequiredServices(requiredServices);
service = resolveService(info, parentInfo);
assertEquals(requiredServices, service.getModuleInfo().getRequiredServices());
// specified in both
info.setRequiredServices(requiredServices);
parentInfo.setRequiredServices(Collections.singletonList("other"));
service = resolveService(info, parentInfo);
assertEquals(requiredServices, service.getModuleInfo().getRequiredServices());
// not set in either
info.setRequiredServices(null);
parentInfo.setRequiredServices(null);
service = resolveService(info, parentInfo);
assertTrue(service.getModuleInfo().getRequiredServices().isEmpty());
}
@Test
public void testResolve_Configuration__ExcludedTypes__ParentType() throws Exception {
// child
ServiceInfo info = new ServiceInfo();
info.setExcludedConfigTypes(Collections.singleton("BAR"));
// FOO
Collection<PropertyInfo> fooProperties = new ArrayList<PropertyInfo>();
PropertyInfo prop1 = new PropertyInfo();
prop1.setName("name1");
prop1.setValue("val1");
fooProperties.add(prop1);
PropertyInfo prop2 = new PropertyInfo();
prop2.setName("name2");
prop2.setValue("val2");
fooProperties.add(prop2);
ConfigurationModule childConfigModule = createConfigurationModule("FOO", fooProperties);
Collection<ConfigurationModule> childConfigModules = new ArrayList<ConfigurationModule>();
childConfigModules.add(childConfigModule);
// parent
ServiceInfo parentInfo = new ServiceInfo();
// BAR
Collection<PropertyInfo> barProperties = new ArrayList<PropertyInfo>();
PropertyInfo prop3 = new PropertyInfo();
prop3.setName("name1");
prop3.setValue("val3");
barProperties.add(prop3);
ConfigurationModule parentConfigModule = createConfigurationModule("BAR", barProperties);
Collection<ConfigurationModule> parentConfigModules = new ArrayList<ConfigurationModule>();
parentConfigModules.add(parentConfigModule);
// create service modules
ServiceModule service = createServiceModule(info, childConfigModules);
ServiceModule parentService = createServiceModule(parentInfo, parentConfigModules);
// resolve child with parent
resolveService(service, parentService);
// assertions
List<PropertyInfo> properties = service.getModuleInfo().getProperties();
assertEquals(2, properties.size());
Map<String, Map<String, Map<String, String>>> attributes =
service.getModuleInfo().getConfigTypeAttributes();
assertEquals(1, attributes.size());
assertTrue(attributes.containsKey("FOO"));
Map<String, Map<String, Map<String, String>>> parentAttributes =
parentService.getModuleInfo().getConfigTypeAttributes();
assertEquals(1, parentAttributes.size());
assertTrue(parentAttributes.containsKey("BAR"));
}
@Test
public void testServiceCheckRegistered() throws Exception {
ServiceInfo info = new ServiceInfo();
info.setName("service1");
info.setCommandScript(createNiceMock(CommandScriptDefinition.class));
StackContext context = createStackContext(info.getName(), true);
ServiceModule service =
createServiceModule(info, Collections.<ConfigurationModule>emptySet(), context);
service.finalizeModule();
verify(context);
}
/**
* Merge components with the parent configurations. This will update the child component module
* set as well as the underlying info instances.
*
* @param parent parent service module
* @param allStacks all stack modules
* @param commonServices common service modules
*/
private void mergeComponents(
ServiceModule parent,
Map<String, StackModule> allStacks,
Map<String, ServiceModule> commonServices)
throws AmbariException {
serviceInfo.getComponents().clear();
Collection<ComponentModule> mergedModules =
mergeChildModules(allStacks, commonServices, componentModules, parent.componentModules);
componentModules.clear();
for (ComponentModule module : mergedModules) {
componentModules.put(module.getId(), module);
serviceInfo.getComponents().add(module.getModuleInfo());
}
}
@Test
public void testResolve_CustomCommands() throws Exception {
List<CustomCommandDefinition> customCommands = new ArrayList<CustomCommandDefinition>();
CustomCommandDefinition cmd1 = new CustomCommandDefinition();
setPrivateField(cmd1, "name", "cmd1");
setPrivateField(cmd1, "background", false);
CustomCommandDefinition cmd2 = new CustomCommandDefinition();
setPrivateField(cmd2, "name", "cmd2");
customCommands.add(cmd1);
customCommands.add(cmd2);
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setCustomCommands(customCommands);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(customCommands, service.getModuleInfo().getCustomCommands());
// specified in parent only
info.setCustomCommands(null);
parentInfo.setCustomCommands(customCommands);
service = resolveService(info, parentInfo);
assertEquals(customCommands, service.getModuleInfo().getCustomCommands());
// specified in both
List<CustomCommandDefinition> parentCustomCommands = new ArrayList<CustomCommandDefinition>();
CustomCommandDefinition cmd3 = new CustomCommandDefinition();
setPrivateField(cmd3, "name", "cmd1");
setPrivateField(cmd3, "background", true);
CustomCommandDefinition cmd4 = new CustomCommandDefinition();
setPrivateField(cmd4, "name", "cmd4");
parentCustomCommands.add(cmd3);
parentCustomCommands.add(cmd4);
info.setCustomCommands(customCommands);
parentInfo.setCustomCommands(parentCustomCommands);
service = resolveService(info, parentInfo);
Collection<CustomCommandDefinition> mergedCommands =
service.getModuleInfo().getCustomCommands();
assertEquals(3, mergedCommands.size());
assertTrue(mergedCommands.contains(cmd2));
assertTrue(mergedCommands.contains(cmd3));
assertTrue(mergedCommands.contains(cmd4));
// not set in either
info.setCustomCommands(null);
parentInfo.setCustomCommands(null);
service = resolveService(info, parentInfo);
assertTrue(service.getModuleInfo().getCustomCommands().isEmpty());
}
@Test
public void testResolve_Configuration__ExcludedTypes() throws Exception {
ServiceInfo info = new ServiceInfo();
info.setExcludedConfigTypes(Collections.singleton("BAR"));
// FOO
Collection<PropertyInfo> fooProperties = new ArrayList<PropertyInfo>();
PropertyInfo prop1 = new PropertyInfo();
prop1.setName("name1");
prop1.setValue("val1");
fooProperties.add(prop1);
PropertyInfo prop2 = new PropertyInfo();
prop2.setName("name2");
prop2.setValue("val2");
fooProperties.add(prop2);
// BAR
Collection<PropertyInfo> barProperties = new ArrayList<PropertyInfo>();
PropertyInfo prop3 = new PropertyInfo();
prop3.setName("name1");
prop3.setValue("val3");
barProperties.add(prop3);
// OTHER
Collection<PropertyInfo> otherProperties = new ArrayList<PropertyInfo>();
PropertyInfo prop4 = new PropertyInfo();
prop4.setName("name1");
prop4.setValue("val4");
otherProperties.add(prop4);
ConfigurationModule configModule1 = createConfigurationModule("FOO", fooProperties);
ConfigurationModule configModule2 = createConfigurationModule("BAR", barProperties);
ConfigurationModule configModule3 = createConfigurationModule("OTHER", otherProperties);
Collection<ConfigurationModule> configModules = new ArrayList<ConfigurationModule>();
configModules.add(configModule1);
configModules.add(configModule2);
configModules.add(configModule3);
ServiceModule service = createServiceModule(info, configModules);
List<PropertyInfo> properties = service.getModuleInfo().getProperties();
assertEquals(4, properties.size());
Map<String, Map<String, Map<String, String>>> attributes =
service.getModuleInfo().getConfigTypeAttributes();
assertEquals(2, attributes.size());
assertTrue(attributes.containsKey("FOO"));
assertTrue(attributes.containsKey("OTHER"));
}
private ServiceModule createServiceModule(
ServiceInfo serviceInfo,
Collection<ConfigurationModule> configurations,
StackContext context) {
if (serviceInfo.getName() == null) {
serviceInfo.setName("service1");
}
ConfigurationDirectory configDirectory = createConfigurationDirectory(configurations);
ServiceDirectory serviceDirectory =
createServiceDirectory(serviceInfo.getConfigDir(), configDirectory);
return createServiceModule(context, serviceInfo, serviceDirectory);
}
/** Finalize service configurations. Ensure that all default type attributes are set. */
private void finalizeConfiguration() {
for (ConfigurationModule config : configurationModules.values()) {
ConfigurationInfo configInfo = config.getModuleInfo();
configInfo.ensureDefaultAttributes();
serviceInfo.setTypeAttributes(config.getConfigType(), configInfo.getAttributes());
}
}
@Test
public void testResolve_RestartRequiredAfterChange() throws Exception {
Boolean isRestartRequired = true;
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setRestartRequiredAfterChange(isRestartRequired);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(isRestartRequired, service.getModuleInfo().isRestartRequiredAfterChange());
// specified in parent only
info.setRestartRequiredAfterChange(null);
parentInfo.setRestartRequiredAfterChange(isRestartRequired);
service = resolveService(info, parentInfo);
assertEquals(isRestartRequired, service.getModuleInfo().isRestartRequiredAfterChange());
// specified in both
info.setRestartRequiredAfterChange(isRestartRequired);
parentInfo.setRestartRequiredAfterChange(false);
service = resolveService(info, parentInfo);
assertEquals(isRestartRequired, service.getModuleInfo().isRestartRequiredAfterChange());
}
@Test
public void testResolve_MonitoringService() throws Exception {
Boolean isMonitoringService = true;
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setMonitoringService(isMonitoringService);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(isMonitoringService, service.getModuleInfo().isMonitoringService());
// specified in parent only
info.setMonitoringService(null);
parentInfo.setMonitoringService(isMonitoringService);
service = resolveService(info, parentInfo);
assertEquals(isMonitoringService, service.getModuleInfo().isMonitoringService());
// specified in both
info.setMonitoringService(isMonitoringService);
parentInfo.setMonitoringService(false);
service = resolveService(info, parentInfo);
assertEquals(isMonitoringService, service.getModuleInfo().isMonitoringService());
}
@Test
public void testResolve_OsSpecifics() throws Exception {
Map<String, ServiceOsSpecific> osSpecifics = new HashMap<String, ServiceOsSpecific>();
osSpecifics.put("foo", new ServiceOsSpecific());
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setOsSpecifics(osSpecifics);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(osSpecifics, service.getModuleInfo().getOsSpecifics());
// specified in parent only
info.setOsSpecifics(null);
parentInfo.setOsSpecifics(osSpecifics);
service = resolveService(info, parentInfo);
assertEquals(osSpecifics, service.getModuleInfo().getOsSpecifics());
// specified in both
Map<String, ServiceOsSpecific> osSpecifics2 = new HashMap<String, ServiceOsSpecific>();
osSpecifics.put("bar", new ServiceOsSpecific());
info.setOsSpecifics(osSpecifics);
parentInfo.setOsSpecifics(osSpecifics2);
service = resolveService(info, parentInfo);
assertEquals(osSpecifics, service.getModuleInfo().getOsSpecifics());
}
@Test
public void testResolve_CommandScript() throws Exception {
CommandScriptDefinition commandScript = new CommandScriptDefinition();
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setCommandScript(commandScript);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(commandScript, service.getModuleInfo().getCommandScript());
// specified in parent only
info.setCommandScript(null);
parentInfo.setCommandScript(commandScript);
service = resolveService(info, parentInfo);
assertEquals(commandScript, service.getModuleInfo().getCommandScript());
// specified in both
CommandScriptDefinition commandScript2 = new CommandScriptDefinition();
info.setCommandScript(commandScript);
parentInfo.setCommandScript(commandScript2);
service = resolveService(info, parentInfo);
assertEquals(commandScript, service.getModuleInfo().getCommandScript());
}
@Test
public void testResolve_Comment() throws Exception {
String comment = "test comment";
// comment specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setComment(comment);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(comment, service.getModuleInfo().getComment());
// comment specified in parent only
info.setComment(null);
parentInfo.setComment(comment);
service = resolveService(info, parentInfo);
assertEquals(comment, service.getModuleInfo().getComment());
// set in both
info.setComment(comment);
parentInfo.setComment("other comment");
service = resolveService(info, parentInfo);
assertEquals(comment, service.getModuleInfo().getComment());
}
@Test
public void testResolve_DisplayName() throws Exception {
String displayName = "test_display_name";
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setDisplayName(displayName);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(displayName, service.getModuleInfo().getDisplayName());
// specified in parent only
info.setDisplayName(null);
parentInfo.setDisplayName(displayName);
service = resolveService(info, parentInfo);
assertEquals(displayName, service.getModuleInfo().getDisplayName());
// specified in both
info.setDisplayName(displayName);
parentInfo.setDisplayName("other display name");
service = resolveService(info, parentInfo);
assertEquals(displayName, service.getModuleInfo().getDisplayName());
}
@Test
public void testResolve_Version() throws Exception {
String version = "1.1";
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setVersion(version);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(version, service.getModuleInfo().getVersion());
// specified in parent only
info.setVersion(null);
parentInfo.setVersion(version);
service = resolveService(info, parentInfo);
assertEquals(version, service.getModuleInfo().getVersion());
// specified in both
info.setVersion(version);
parentInfo.setVersion("1.0");
service = resolveService(info, parentInfo);
assertEquals(version, service.getModuleInfo().getVersion());
}
/** Merge theme modules. */
private void mergeThemes(
ServiceModule parent,
Map<String, StackModule> allStacks,
Map<String, ServiceModule> commonServices)
throws AmbariException {
Collection<ThemeModule> mergedModules =
mergeChildModules(allStacks, commonServices, themeModules, parent.themeModules);
for (ThemeModule mergedModule : mergedModules) {
themeModules.put(mergedModule.getId(), mergedModule);
ThemeInfo moduleInfo = mergedModule.getModuleInfo();
if (!moduleInfo.isDeleted()) {
serviceInfo.getThemesMap().put(moduleInfo.getFileName(), moduleInfo);
} else {
serviceInfo.getThemesMap().remove(moduleInfo.getFileName());
}
}
}
/**
* Merge configuration dependencies with parent. Child values override parent values.
*
* @param parent parent service module
*/
private void mergeConfigDependencies(ServiceInfo parent) {
// currently there is no way to remove an inherited config dependency
List<String> configDependencies = serviceInfo.getConfigDependencies();
List<String> parentConfigDependencies =
parent.getConfigDependencies() != null
? parent.getConfigDependencies()
: Collections.<String>emptyList();
if (configDependencies == null) {
serviceInfo.setConfigDependencies(parentConfigDependencies);
} else {
for (String parentDependency : parentConfigDependencies) {
if (!configDependencies.contains(parentDependency)) {
configDependencies.add(parentDependency);
}
}
}
}
@Override
public void finalizeModule() {
finalizeChildModules(configurationModules.values());
finalizeChildModules(componentModules.values());
finalizeConfiguration();
if (serviceInfo.getCommandScript() != null && !isDeleted()) {
stackContext.registerServiceCheck(getId());
}
}
private void populateThemeModules() {
if (serviceInfo.getThemesDir() == null) {
serviceInfo.setThemesDir(AmbariMetaInfo.SERVICE_THEMES_FOLDER_NAME);
}
String themesDir =
serviceDirectory.getAbsolutePath() + File.separator + serviceInfo.getThemesDir();
if (serviceInfo.getThemes() != null) {
for (ThemeInfo themeInfo : serviceInfo.getThemes()) {
File themeFile = new File(themesDir + File.separator + themeInfo.getFileName());
ThemeModule module = new ThemeModule(themeFile, themeInfo);
themeModules.put(module.getId(), module);
}
}
// lets not fail if theme contain errors
}
/**
* Merge configurations with the parent configurations. This will update the child configuration
* module set as well as the underlying info instances.
*
* @param parent parent service module
* @param allStacks all stack modules
* @param commonServices common service modules
*/
private void mergeConfigurations(
ServiceModule parent,
Map<String, StackModule> allStacks,
Map<String, ServiceModule> commonServices)
throws AmbariException {
serviceInfo.getProperties().clear();
serviceInfo.setAllConfigAttributes(new HashMap<String, Map<String, Map<String, String>>>());
Collection<ConfigurationModule> mergedModules =
mergeChildModules(
allStacks, commonServices, configurationModules, parent.configurationModules);
for (ConfigurationModule module : mergedModules) {
configurationModules.put(module.getId(), module);
if (!module.isDeleted()) {
serviceInfo.getProperties().addAll(module.getModuleInfo().getProperties());
serviceInfo.setTypeAttributes(
module.getConfigType(), module.getModuleInfo().getAttributes());
}
}
}
private ServiceModule createServiceModule(ServiceInfo serviceInfo) {
String configType = "type1";
if (serviceInfo.getName() == null) {
serviceInfo.setName("service1");
}
StackContext context = createStackContext(serviceInfo.getName(), true);
// no config props
ConfigurationInfo configInfo =
createConfigurationInfo(
Collections.<PropertyInfo>emptyList(), Collections.<String, String>emptyMap());
ConfigurationModule module = createConfigurationModule(configType, configInfo);
ConfigurationDirectory configDirectory =
createConfigurationDirectory(Collections.singletonList(module));
ServiceDirectory serviceDirectory =
createServiceDirectory(serviceInfo.getConfigDir(), configDirectory);
return createServiceModule(context, serviceInfo, serviceDirectory);
}
@Test
public void testResolve_ConfigDependencies() throws Exception {
List<String> configDependencies = new ArrayList<String>();
configDependencies.add("foo");
configDependencies.add("bar");
// specified in child only
ServiceInfo info = new ServiceInfo();
ServiceInfo parentInfo = new ServiceInfo();
info.setConfigDependencies(configDependencies);
ServiceModule service = resolveService(info, parentInfo);
assertEquals(configDependencies, service.getModuleInfo().getConfigDependencies());
// specified in parent only
info.setConfigDependencies(null);
parentInfo.setConfigDependencies(configDependencies);
service = resolveService(info, parentInfo);
assertEquals(configDependencies, service.getModuleInfo().getConfigDependencies());
// specified in both
List<String> parentCustomCommands = new ArrayList<String>();
parentCustomCommands.add("bar");
parentCustomCommands.add("other");
info.setConfigDependencies(configDependencies);
parentInfo.setConfigDependencies(parentCustomCommands);
service = resolveService(info, parentInfo);
Collection<String> mergedConfigDependencies = service.getModuleInfo().getConfigDependencies();
assertEquals(3, mergedConfigDependencies.size());
assertTrue(mergedConfigDependencies.contains("foo"));
assertTrue(mergedConfigDependencies.contains("bar"));
assertTrue(mergedConfigDependencies.contains("other"));
// not set in either
info.setConfigDependencies(null);
parentInfo.setConfigDependencies(null);
service = resolveService(info, parentInfo);
assertTrue(service.getModuleInfo().getConfigDependencies().isEmpty());
}
@Test
public void testMerge_Configuration__ExcludedTypes() throws Exception {
// child
ServiceInfo info = new ServiceInfo();
Set<String> childExcludedConfigTypes = new HashSet<String>();
childExcludedConfigTypes.add("FOO");
info.setExcludedConfigTypes(childExcludedConfigTypes);
// FOO
Collection<PropertyInfo> fooProperties = new ArrayList<PropertyInfo>();
ConfigurationModule childConfigModule = createConfigurationModule("FOO", fooProperties);
Collection<ConfigurationModule> childConfigModules = new ArrayList<ConfigurationModule>();
childConfigModules.add(childConfigModule);
// parent
ServiceInfo parentInfo = new ServiceInfo();
Set<String> parentExcludedConfigTypes = new HashSet<String>();
childExcludedConfigTypes.add("BAR");
info.setExcludedConfigTypes(childExcludedConfigTypes);
parentInfo.setExcludedConfigTypes(parentExcludedConfigTypes);
// BAR
Collection<PropertyInfo> barProperties = new ArrayList<PropertyInfo>();
ConfigurationModule parentConfigModule = createConfigurationModule("BAR", barProperties);
Collection<ConfigurationModule> parentConfigModules = new ArrayList<ConfigurationModule>();
parentConfigModules.add(parentConfigModule);
// create service modules
ServiceModule service = createServiceModule(info, childConfigModules);
ServiceModule parentService = createServiceModule(parentInfo, parentConfigModules);
// resolve child with parent
resolveService(service, parentService);
// resolveService(service, parentService);
assertEquals(2, service.getModuleInfo().getExcludedConfigTypes().size());
}
/**
* Merge excluded configs types with parent. Child values override parent values.
*
* @param parent parent service module
*/
private void mergeExcludedConfigTypes(ServiceInfo parent) {
if (serviceInfo.getExcludedConfigTypes() == null) {
serviceInfo.setExcludedConfigTypes(parent.getExcludedConfigTypes());
} else if (parent.getExcludedConfigTypes() != null) {
Set<String> resultExcludedConfigTypes = serviceInfo.getExcludedConfigTypes();
for (String excludedType : parent.getExcludedConfigTypes()) {
if (!resultExcludedConfigTypes.contains(excludedType)) {
resultExcludedConfigTypes.add(excludedType);
}
}
serviceInfo.setExcludedConfigTypes(resultExcludedConfigTypes);
}
}
/**
* Resolve common service
*
* @param allStacks all stack modules
* @param commonServices common service modules
* @throws AmbariException
*/
public void resolveCommonService(
Map<String, StackModule> allStacks, Map<String, ServiceModule> commonServices)
throws AmbariException {
if (!isCommonService) {
throw new AmbariException("Not a common service");
}
moduleState = ModuleState.VISITED;
String parentString = serviceInfo.getParent();
if (parentString != null) {
String[] parentToks = parentString.split(StackManager.PATH_DELIMITER);
if (parentToks.length != 3) {
throw new AmbariException(
"The common service '"
+ serviceInfo.getName()
+ serviceInfo.getVersion()
+ "' extends an invalid parent: '"
+ parentString
+ "'");
}
if (parentToks[0].equalsIgnoreCase(StackManager.COMMON_SERVICES)) {
String baseServiceKey = parentToks[1] + StackManager.PATH_DELIMITER + parentToks[2];
ServiceModule baseService = commonServices.get(baseServiceKey);
ModuleState baseModuleState = baseService.getModuleState();
if (baseModuleState == ModuleState.INIT) {
baseService.resolveCommonService(allStacks, commonServices);
} else if (baseModuleState == ModuleState.VISITED) {
// todo: provide more information to user about cycle
throw new AmbariException("Cycle detected while parsing common service");
}
resolve(baseService, allStacks, commonServices);
} else {
throw new AmbariException("Common service cannot inherit from a non common service");
}
}
moduleState = ModuleState.RESOLVED;
}
/**
* Constructor.
*
* @param stackContext stack context which provides module access to external functionality
* @param serviceInfo associated service info
* @param serviceDirectory used for all IO interaction with service directory in stack definition
* @param isCommonService flag to mark a service as a common service
*/
public ServiceModule(
StackContext stackContext,
ServiceInfo serviceInfo,
ServiceDirectory serviceDirectory,
boolean isCommonService) {
this.serviceInfo = serviceInfo;
this.stackContext = stackContext;
this.serviceDirectory = serviceDirectory;
this.isCommonService = isCommonService;
serviceInfo.setMetricsFile(serviceDirectory.getMetricsFile(serviceInfo.getName()));
serviceInfo.setAlertsFile(serviceDirectory.getAlertsFile());
serviceInfo.setKerberosDescriptorFile(serviceDirectory.getKerberosDescriptorFile());
serviceInfo.setWidgetsDescriptorFile(
serviceDirectory.getWidgetsDescriptorFile(serviceInfo.getName()));
serviceInfo.setSchemaVersion(AmbariMetaInfo.SCHEMA_VERSION_2);
serviceInfo.setServicePackageFolder(serviceDirectory.getPackageDir());
populateComponentModules();
populateConfigurationModules();
populateThemeModules();
validateServiceInfo();
}
private void validateServiceInfo() {
if (!serviceInfo.isValid()) {
setValid(false);
setErrors(serviceInfo.getErrors());
}
}