hostComponent.get('actualConfigs').forEach(function(config){
if(serviceTemplate.sites.contains(config.site)){
var desiredClusterTag = clusterToDesiredMap[config.site].tag;
var desiredHostOverrideTag = clusterToDesiredMap[config.site].hostOverrides[hostName];
var actualClusterTag = config.tag;
var actualHostOverrideTag = config.hostOverrides[hostName];
var siteRestartRequired = false;
if(actualClusterTag !== desiredClusterTag || actualHostOverrideTag !== desiredHostOverrideTag){
var publicHostName = host.get('publicHostName');
if(config.site=='global'){
var serviceName = hostComponent.get('service.serviceName');
if(actualClusterTag !== desiredClusterTag){
siteRestartRequired = App.config.isServiceEffectedByGlobalChange(serviceName, actualClusterTag, desiredClusterTag);
}
if(actualHostOverrideTag !== desiredHostOverrideTag){
siteRestartRequired = App.config.isServiceEffectedByGlobalChange(serviceName, actualHostOverrideTag, desiredHostOverrideTag);
}
}else{
siteRestartRequired = true
}
if(siteRestartRequired){
restartRequired = true;
if(!(publicHostName in restartRequiredHostsAndComponents)){
restartRequiredHostsAndComponents[publicHostName] = [];
}
var hostComponentName = hostComponent.get('displayName');
if(restartRequiredHostsAndComponents[publicHostName].indexOf(hostComponentName)<0){
restartRequiredHostsAndComponents[publicHostName].push(hostComponentName);
}
}
}
}
});
it('should return "AdvancedCoreSite" if filename "core-site.xml" and serviceName "HDFS"', function () {
data = {
serviceName: 'HDFS',
filename: 'core-site.xml'
}
expect(App.config.identifyCategory(data).name).to.equal('AdvancedCoreSite');
});
loadConfigThemes: function () {
var self = this;
var dfd = $.Deferred();
if (!this.get('stackConfigsLoaded')) {
var serviceNames = App.StackService.find().filter(function (s) {
return s.get('isSelected') || s.get('isInstalled');
}).mapProperty('serviceName');
// Load stack configs before loading themes
App.config.loadClusterConfigsFromStack().always(function() {
App.config.loadConfigsFromStack(serviceNames).done(function () {
if (App.get('isClusterSupportsEnhancedConfigs')) {
self.loadConfigThemeForServices(serviceNames).always(function () {
self.set('stackConfigsLoaded', true);
App.themesMapper.generateAdvancedTabs(serviceNames);
dfd.resolve();
});
} else {
self.set('stackConfigsLoaded', true);
dfd.resolve();
}
});
});
}
else {
dfd.resolve();
this.set('stackConfigsLoaded', true);
}
return dfd.promise();
},
componentProperties: function (serviceName) {
var serviceConfigs = App.config.get('preDefinedServiceConfigs').findProperty('serviceName', serviceName);
var configs = [];
var componentName = null;
switch (serviceName) {
case 'HDFS':
componentName = 'DataNode';
break;
case 'MAPREDUCE':
componentName = 'TaskTracker';
break;
case 'HBASE':
componentName = 'RegionServer';
}
var slaveConfigs = serviceConfigs.configs.filterProperty('category', componentName);
slaveConfigs.forEach(function (_serviceConfigProperty) {
var serviceConfigProperty = App.ServiceConfigProperty.create(_serviceConfigProperty);
switch(serviceConfigProperty.name){
case 'dfs_data_dir' :
serviceConfigProperty.initialValue();
break;
case 'mapred_local_dir' :
serviceConfigProperty.initialValue();
break;
}
configs.pushObject(serviceConfigProperty);
serviceConfigProperty.validate();
}, this);
return configs;
},
it('should return "CapacityScheduler" if filename "capacity-scheduler.xml" and serviceName "YARN"', function () {
data = {
serviceName: 'YARN',
filename: 'capacity-scheduler.xml'
}
expect(App.config.identifyCategory(data).name).to.equal('CapacityScheduler');
});
it('isUserProperty should be true if config is custom(site.xml) and not advanced', function () {
config = {
serviceName: 'HDFS',
filename: 'core-site.xml'
};
App.config.calculateConfigProperties(config, isAdvanced, advancedConfigs);
expect(config.isUserProperty).to.equal(true);
});
getConfigId: function(json) {
if (json && json.config && typeof json.config === "string") {
var split = json.config.split("/");
return App.config.configId(split[1], split[0]);
} else {
console.warn('getConfigId: invalid input data');
return null;
}
},
Em.getWithDefault(json, "ThemeInfo.theme_data.Theme.configuration.placement.configs", []).forEach(function(configLink) {
var configId = this.getConfigId(configLink);
var subSectionId = configLink["subsection-name"];
var subSectionTabId = configLink["subsection-tab-name"];
if (subSectionTabId) {
var subSectionTab = App.SubSectionTab.find(subSectionTabId);
} else if (subSectionId) {
var subSection = App.SubSection.find(subSectionId);
}
var configProperty = App.StackConfigProperty.find(configId);
var dependsOnConfigs = configLink["depends-on"] || [];
if (configProperty.get('id') && subSection) {
subSection.get('configProperties').pushObject(configProperty);
configProperty.set('subSection', subSection);
} else if (configProperty.get('id') && subSectionTab) {
subSectionTab.get('configProperties').pushObject(configProperty);
configProperty.set('subSectionTab', subSectionTab);
} else {
console.log('there is no such property: ' + configId + '. Or subsection: ' + subSectionId);
var valueAttributes = configLink["property_value_attributes"];
if (valueAttributes) {
var isUiOnlyProperty = valueAttributes["ui_only_property"];
// UI only configs are mentioned in the themes for supporting widgets that is not intended for setting a value
// And thus is affiliated with fake config property termed as ui only config property
if (isUiOnlyProperty && subSection) {
var split = configLink.config.split("/");
var fileName = split[0] + '.xml';
var configName = split[1];
var uiOnlyConfig = App.uiOnlyConfigDerivedFromTheme.filterProperty('filename', fileName).findProperty('name', configName);
if (!uiOnlyConfig) {
var coreObject = {
id: configName + '_' + split[0],
isRequiredByAgent: false,
showLabel: false,
isOverridable: false,
recommendedValue: true,
name: configName,
isUserProperty: false,
filename: fileName,
serviceName: serviceName,
subSection: subSection
};
var uiOnlyConfigDerivedFromTheme = Em.Object.create(App.config.createDefaultConfig(configName, serviceName, fileName, false, coreObject));
App.uiOnlyConfigDerivedFromTheme.pushObject(uiOnlyConfigDerivedFromTheme);
}
}
}
}
// map all the configs which conditionally affect the value attributes of a config
if (dependsOnConfigs && dependsOnConfigs.length) {
this.mapThemeConfigConditions(dependsOnConfigs, uiOnlyConfigDerivedFromTheme || configProperty);
}
}, this);
_content.get('configs').forEach(function (_configProperties) {
if (!Em.isNone(_configProperties.get('group'))) {
return false;
}
var configProperty = App.config.createDefaultConfig(
_configProperties.get('name'),
_configProperties.get('serviceName'),
_configProperties.get('filename'),
_configProperties.get('isUserProperty'),
{value: _configProperties.get('value')}
);
configProperty = App.config.mergeStaticProperties(configProperty, _configProperties, ['name', 'filename']);
if (this.isExcludedConfig(configProperty)) {
configProperty.value = '';
}
serviceConfigProperties.push(configProperty);
}, this);
it('value should be transformed to false from "false"', function () {
config = {
displayType: 'checkbox',
value: 'false',
defaultValue: 'false'
};
App.config.handleSpecialProperties(config);
expect(config.value).to.equal(false);
expect(config.defaultValue).to.equal(false);
});
it('value should be transformed to "1024" from "1024m"', function () {
config = {
displayType: 'int',
value: '1024m',
defaultValue: '1024m'
};
App.config.handleSpecialProperties(config);
expect(config.value).to.equal('1024');
expect(config.defaultValue).to.equal('1024');
});
it('isUserProperty should be false if config from "capacity-scheduler.xml" or "mapred-queue-acls.xml" ', function () {
config = {
name: 'test',
serviceName: 'MAPREDUCE',
filename: 'capacity-scheduler.xml',
isUserProperty: false
};
isAdvanced = true;
App.config.calculateConfigProperties(config, isAdvanced, advancedConfigs);
expect(config.isUserProperty).to.equal(false);
});
getServerVersionSuccessCallback: function (data) {
var clientVersion = App.get('version');
var serverVersion = (data.RootServiceComponents.component_version).toString();
this.set('ambariServerVersion', serverVersion);
if (clientVersion) {
this.set('versionConflictAlertBody', Em.I18n.t('app.versionMismatchAlert.body').format(serverVersion, clientVersion));
this.set('isServerClientVersionMismatch', clientVersion != serverVersion);
} else {
this.set('isServerClientVersionMismatch', false);
}
App.set('isManagedMySQLForHiveEnabled', App.config.isManagedMySQLForHiveAllowed(data.RootServiceComponents.properties['server.os_family']));
},
it('isRequired should be false if config is advanced"', function () {
config = {
name: 'test',
serviceName: 'HDFS',
filename: 'core-site.xml'
};
isAdvanced = true;
advancedConfigs = [{name:'test', filename: 'test.xml'}];
App.config.calculateConfigProperties(config, isAdvanced, advancedConfigs);
expect(config.category).to.equal('Advanced');
expect(config.isRequired).to.equal(true);
expect(config.filename).to.equal('test.xml');
});
setDynamicConfigValues: function (configs, zkPort, webAddressPort, httpsWebAddressPort, yarnUser) {
var
configProperties = configs.configs,
currentRMHost = this.get('content.rmHosts.currentRM'),
additionalRMHost = this.get('content.rmHosts.additionalRM'),
rmHosts = currentRMHost + ',' + additionalRMHost,
zooKeeperHostsWithPort = App.HostComponent.find().filterProperty('componentName', 'ZOOKEEPER_SERVER').map(function (item) {
return item.get('hostName') + ':' + zkPort;
}).join(',');
configProperties.findProperty('name', 'yarn.resourcemanager.hostname.rm1').set('value', currentRMHost).set('recommendedValue', currentRMHost);
configProperties.findProperty('name', 'yarn.resourcemanager.hostname.rm2').set('value', additionalRMHost).set('recommendedValue', additionalRMHost);
configProperties.findProperty('name', 'yarn.resourcemanager.zk-address').set('value', zooKeeperHostsWithPort).set('recommendedValue', zooKeeperHostsWithPort);
configProperties.findProperty('name', 'yarn.resourcemanager.webapp.address.rm1')
.set('value', currentRMHost + webAddressPort)
.set('recommendedValue', currentRMHost + webAddressPort);
configProperties.findProperty('name', 'yarn.resourcemanager.webapp.address.rm2')
.set('value', additionalRMHost + webAddressPort)
.set('recommendedValue', additionalRMHost + webAddressPort);
configProperties.findProperty('name', 'yarn.resourcemanager.webapp.https.address.rm1')
.set('value', currentRMHost + httpsWebAddressPort)
.set('recommendedValue', currentRMHost + httpsWebAddressPort);
configProperties.findProperty('name', 'yarn.resourcemanager.webapp.https.address.rm2')
.set('value', additionalRMHost + httpsWebAddressPort)
.set('recommendedValue', additionalRMHost + httpsWebAddressPort);
var proxyUserConfig = App.ServiceConfigProperty.create(App.config.createDefaultConfig('hadoop.proxyuser.' + yarnUser + '.hosts',
'MISC', 'core-site', false, {category : "HDFS", isUserProperty: false, isEditable: false, isOverridable: false}));
configProperties.pushObject(proxyUserConfig);
proxyUserConfig.setProperties({'value': rmHosts, 'recommendedValue': rmHosts});
if (App.Service.find().someProperty('serviceName', 'HAWQ')) {
var yarnHAPort = 8032;
var yarnHAHosts = currentRMHost + ':' + yarnHAPort.toString() + ',' + additionalRMHost + ':' + yarnHAPort.toString();
configProperties.findProperty('name', 'yarn.resourcemanager.ha')
.set('value', yarnHAHosts)
.set('recommendedValue', yarnHAHosts);
var yarnHASchPort = 8030;
var yarnHASchHosts = currentRMHost + ':' + yarnHASchPort.toString() + ',' + additionalRMHost + ':' + yarnHASchPort.toString();
configProperties.findProperty('name', 'yarn.resourcemanager.scheduler.ha')
.set('value', yarnHASchHosts)
.set('recommendedValue', yarnHASchHosts);
}
},
App.config.loadClusterConfigsFromStack().always(function() {
App.config.loadConfigsFromStack(serviceNames).done(function () {
if (App.get('isClusterSupportsEnhancedConfigs')) {
self.loadConfigThemeForServices(serviceNames).always(function () {
self.set('stackConfigsLoaded', true);
App.themesMapper.generateAdvancedTabs(serviceNames);
dfd.resolve();
});
} else {
self.set('stackConfigsLoaded', true);
dfd.resolve();
}
});
});
loadConfigsByTags: function (tags,dfd) {
var self = this;
var loadedConfigs = [];
App.config.loadConfigsByTags(tags).done(function (data) {
if (data.items) {
data.items.forEach(function (item) {
loadedConfigs.push(item);
});
}
}).complete(function () {
self.saveToDB(loadedConfigs);
dfd.resolve(loadedConfigs);
});
},
loadFromServer: function (tags) {
var loadedConfigs = App.config.loadConfigsByTags(tags);
var storedConfigs = App.db.getConfigs();
loadedConfigs.forEach(function (loadedSite) {
var storedSite = storedConfigs.findProperty('type', loadedSite.type);
if (storedSite) {
storedSite.tag = loadedSite.tag;
storedSite.properties = loadedSite.properties;
} else {
storedConfigs.push(loadedSite);
}
});
App.db.setConfigs(storedConfigs);
return loadedConfigs;
}
prepareConfigProperties: function (configs) {
var self = this;
var configProperties = configs.slice(0);
var siteProperties = App.config.get('preDefinedSiteProperties');
var installedServiceNames = ['Cluster'].concat(App.Service.find().mapProperty('serviceName'));
configProperties = configProperties.filter(function (item) {
return installedServiceNames.contains(item.get('serviceName'));
});
configProperties.setEach('isSecureConfig', false);
configProperties.forEach(function (property, item, allConfigs) {
if (['spnego_keytab', 'spnego_principal'].contains(property.get('name'))) {
property.addObserver('value', self, 'spnegoPropertiesObserver');
}
if (property.get('observesValueFrom')) {
var observedValue = allConfigs.findProperty('name', property.get('observesValueFrom')).get('value');
property.set('value', observedValue);
property.set('recommendedValue', observedValue);
}
if (property.get('serviceName') == 'Cluster') {
property.set('category', 'Global');
} else {
property.set('category', property.get('serviceName'));
}
// All user identity should be grouped under "Ambari Principals" category
if (property.get('identityType') == 'user') property.set('category', 'Ambari Principals');
var siteProperty = siteProperties.findProperty('name', property.get('name'));
if (siteProperty) {
if (siteProperty.category === property.get('category')) {
property.set('displayName', siteProperty.displayName);
if (siteProperty.index) {
property.set('index', siteProperty.index);
}
}
if (siteProperty.displayType) {
property.set('displayType', siteProperty.displayType);
}
}
});
configProperties.setEach('isEditable', false);
return configProperties;
},
stepController.get('stepConfigs').forEach(function (_content) {
if (_content.serviceName === 'YARN') {
_content.set('configs', App.config.textareaIntoFileConfigs(_content.get('configs'), 'capacity-scheduler.xml'));
}
_content.get('configs').forEach(function (_configProperties) {
if (!Em.isNone(_configProperties.get('group'))) {
return false;
}
var configProperty = App.config.createDefaultConfig(
_configProperties.get('name'),
_configProperties.get('serviceName'),
_configProperties.get('filename'),
_configProperties.get('isUserProperty'),
{value: _configProperties.get('value')}
);
configProperty = App.config.mergeStaticProperties(configProperty, _configProperties, ['name', 'filename']);
if (this.isExcludedConfig(configProperty)) {
configProperty.value = '';
}
serviceConfigProperties.push(configProperty);
}, this);
// check for configs that need to update for installed services
if (installedServiceNamesMap[_content.get('serviceName')]) {
// get only modified configs
var configs = _content.get('configs').filter(function (config) {
if (config.get('isNotDefaultValue') || (config.get('savedValue') === null)) {
return config.isRequiredByAgent!== false;
}
return false;
});
// if modified configs detected push all service's configs for update
if (configs.length) {
fileNamesToUpdate = fileNamesToUpdate.concat(configs.mapProperty('filename').uniq());
}
}
}, this);
var App = require('app');
require('utils/config');
App.Service = DS.Model.extend({
serviceName: DS.attr('string'),
displayName: function() {
return App.format.role(this.get('serviceName'));
}.property('serviceName'),
passiveState: DS.attr('string'),
workStatus: DS.attr('string'),
rand: DS.attr('string'),
toolTipContent: DS.attr('string'),
quickLinks: DS.hasMany('App.QuickLinks'), // mapped in app/mappers/service_metrics_mapper.js method - mapQuickLinks
hostComponents: DS.hasMany('App.HostComponent'),
serviceConfigsTemplate: App.config.get('preDefinedServiceConfigs'),
/**
* used by services("OOZIE", "ZOOKEEPER", "HIVE", "MAPREDUCE2", "TEZ", "SQOOP", "PIG","FALCON")
* that have only client components
*/
installedClients: DS.attr('number'),
clientComponents: DS.hasMany('App.ClientComponent'),
slaveComponents: DS.hasMany('App.SlaveComponent'),
masterComponents: DS.hasMany('App.MasterComponent'),
/**
* @type {bool}
*/
isInPassive: function() {
return this.get('passiveState') === "ON";
serviceConfigTags.forEach(function (_serviceConfigTags) {
var configs = _serviceConfigTags.configs;
for (var key in configs) {
configs[key] = App.config.escapeXMLCharacters(configs[key]);
}
}, this);
it('should return null if config doesn\'t have category', function () {
expect(App.config.identifyCategory(data)).to.equal(null);
});