AMBARI-13130. Configs: compare does not return results (alexantonenko)

ambari-web/app/data/HDP2.3/site_properties.js

@@ -170,7 +170,7 @@ hdp23properties.push({
     "filename": "ranger-kms-audit.xml",
     "category": "Advanced ranger-kms-audit",
     "serviceName": "RANGER_KMS"
-  },        
+  },
   {
     "name": "ranger-yarn-plugin-enabled",
     "displayType": "checkbox",

ambari-web/app/mixins/common/configs/configs_comparator.js

@@ -17,6 +17,7 @@
  */
 
 var App = require('app');
+var objectUtils = require('utils/object_utils');
 
 App.ConfigsComparator = Em.Mixin.create({
 
@@ -45,7 +46,6 @@ App.ConfigsComparator = Em.Mixin.create({
       } else {
         compareServiceVersions = [this.get('compareServiceVersion').get('version')];
       }
-
       this.getCompareVersionConfigs(compareServiceVersions).done(function (json) {
         allConfigs.setEach('isEditable', false);
         self.initCompareConfig(allConfigs, json);
@@ -147,7 +147,7 @@ App.ConfigsComparator = Em.Mixin.create({
     } else {
       allConfigs.forEach(function (serviceConfig) {
         var serviceCfgVersionMap = serviceVersionMap[this.get('compareServiceVersion').get('version')];
-        var compareConfig = serviceCfgVersionMap[serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)]
+        var compareConfig = serviceCfgVersionMap[serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)];
         this.setCompareDefaultGroupConfig(serviceConfig, compareConfig);
       }, this);
     }
@@ -248,7 +248,7 @@ App.ConfigsComparator = Em.Mixin.create({
     Em.set(serviceConfig, 'isComparison', true);
 
     //if config isn't reconfigurable then it can't have changed value to compare
-    if (compareConfig && (Em.get(serviceConfig, 'isReconfigurable') || Em.get(serviceConfig, 'isUserProperty'))) {
+    if (compareConfig) {
       compareObject = this.getComparisonConfig(serviceConfig, compareConfig);
       Em.set(serviceConfig, 'hasCompareDiffs', Em.get(serviceConfig, 'isMock') || this.hasCompareDiffs(serviceConfig, compareObject));
       Em.get(serviceConfig, 'compareConfigs').push(compareObject);
@@ -257,6 +257,7 @@ App.ConfigsComparator = Em.Mixin.create({
       Em.get(serviceConfig, 'compareConfigs').push(this.getMockComparisonConfig(serviceConfig, this.get('compareServiceVersion.version')));
       Em.set(serviceConfig, 'hasCompareDiffs', true);
     }
+
     return serviceConfig;
   },
 
@@ -269,7 +270,24 @@ App.ConfigsComparator = Em.Mixin.create({
    * @method hasCompareDiffs
    */
   hasCompareDiffs: function (originalConfig, compareConfig) {
-    return (Em.get(originalConfig, 'value') !== Em.get(compareConfig, 'value')) || (!!Em.get(originalConfig, 'isFinal') !== !!Em.get(compareConfig, 'isFinal'));
+    var originalValue = Em.get(originalConfig, 'value');
+    var compareValue = Em.get(compareConfig, 'value');
+
+    if (originalValue.toArray) {
+      originalValue = originalValue.toArray();
+    }
+    if (compareValue.toArray) {
+      compareValue = compareValue.toArray();
+    }
+
+    if (originalValue instanceof Array) {
+      originalValue.sort();
+    }
+    if (compareValue instanceof Array) {
+      compareValue.sort();
+    }
+
+    return (!objectUtils.deepEqual(originalValue, compareValue)) || (!!Em.get(originalConfig, 'isFinal') !== !!Em.get(compareConfig, 'isFinal'));
   },
 
   /**

ambari-web/app/templates/wizard/master_hosts.hbs

@@ -20,7 +20,7 @@
   {{t installer.noHostsAssigned}}
 {{/if}}
 {{#if view.hasOneHost}}
-  {{value}}
+  {{view.formatValue}}
 {{/if}}
 {{#if view.hasMultipleHosts}}
   <a href="#" {{action showHosts target="view"}}>{{value.firstObject}} {{t and}} {{view.otherLength}}</a>

ambari-web/app/utils/object_utils.js

@@ -51,6 +51,100 @@ module.exports = {
     return r(obj);
   },
 
+  deepEqual: function() {
+    var i, l, leftChain, rightChain;
+    var values = arguments;
+    function compare2Objects (x, y) {
+      var p;
+      if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
+        return true;
+      }
+
+      if (x === y) {
+        return true;
+      }
+
+      if ((typeof x === 'function' && typeof y === 'function') ||
+        (x instanceof Date && y instanceof Date) ||
+        (x instanceof RegExp && y instanceof RegExp) ||
+        (x instanceof String && y instanceof String) ||
+        (x instanceof Number && y instanceof Number)) {
+         return x.toString() === y.toString();
+      }
+
+      if (!(x instanceof Object && y instanceof Object)) {
+        return false;
+      }
+
+      if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
+        return false;
+      }
+
+      if (x.constructor !== y.constructor) {
+        return false;
+      }
+
+      if (x.prototype !== y.prototype) {
+        return false;
+      }
+
+      if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
+        return false;
+      }
+
+      for (p in y) {
+        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+            return false;
+        }
+        else if (typeof y[p] !== typeof x[p]) {
+            return false;
+        }
+      }
+
+      for (p in x) {
+        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+          return false;
+        }
+        else if (typeof y[p] !== typeof x[p]) {
+          return false;
+        }
+        switch (typeof (x[p])) {
+          case 'object':
+          case 'function':
+            leftChain.push(x);
+            rightChain.push(y);
+            if (!compare2Objects (x[p], y[p])) {
+                return false;
+            }
+            leftChain.pop();
+            rightChain.pop();
+            break;
+          default:
+            if (x[p] !== y[p]) {
+                return false;
+            }
+            break;
+        }
+      }
+
+      return true;
+    }
+
+    if (arguments.length < 1) {
+      return true;
+    }
+
+    for (i = 1, l = arguments.length; i < l; i++) {
+      leftChain = [];
+      rightChain = [];
+      if (!compare2Objects(arguments[0], arguments[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
   recursiveTree: function(obj) {
     if (!(obj instanceof Object)) {
       return null;

ambari-web/app/views/common/controls_view.js

@@ -831,12 +831,20 @@ App.ServiceConfigMultipleHostsDisplay = Ember.Mixin.create(App.ServiceConfigHost
     return this.get('value').length === 0;
   }.property('value'),
 
+  formatValue: function() {
+    if (Em.isArray(this.get('value')) && this.get('value').length === 1) {
+      return this.get('value.firstObject');
+    } else {
+      return this.get('value');
+    }
+  }.property('value'),
+
   hasOneHost: function () {
-    return this.get('value').length === 1;
+    return !Em.isArray(this.get('value')) || this.get('value').length === 1;
   }.property('value'),
 
   hasMultipleHosts: function () {
-    return this.get('value').length > 1;
+    return Em.isArray(this.get('value')) && this.get('value').length > 1;
   }.property('value'),
 
   otherLength: function () {

ambari-web/test/controllers/main/service/info/config_test.js

@@ -789,7 +789,7 @@ describe("App.MainServiceInfoConfigsController", function () {
       expect(mainServiceInfoConfigsController.setCompareDefaultGroupConfig({}).compareConfigs.length).to.equal(0);
     });
     it("empty service config and comparison passed, expect that setCompareDefaultGroupConfig will not run anything", function() {
-      expect(mainServiceInfoConfigsController.setCompareDefaultGroupConfig({},{}).compareConfigs.length).to.equal(0);
+      expect(mainServiceInfoConfigsController.setCompareDefaultGroupConfig({},{}).compareConfigs).to.eql(["compConfig"]);
     });
     it("expect that serviceConfig.compareConfigs will be getMockComparisonConfig", function() {
       expect(mainServiceInfoConfigsController.setCompareDefaultGroupConfig({isUserProperty: true}, null)).to.eql({compareConfigs: ["mockConfig"], isUserProperty: true, isComparison: true, hasCompareDiffs: true});

ambari-web/test/utils/object_utils_test.js

@@ -77,4 +77,105 @@ describe('utils/object_utils', function() {
       });
     });
   });
+
+  describe('#deepEqual', function() {
+    it('simple values', function() {
+      expect(objectUtils.deepEqual(true, true)).to.true;
+    });
+    it('simple values strict', function() {
+      expect(objectUtils.deepEqual(true, 1)).to.false;
+    });
+    it('simple with complex', function() {
+      expect(objectUtils.deepEqual(true, {})).to.false;
+    });
+    it('complex with simple', function() {
+      expect(objectUtils.deepEqual({}, 2)).to.false;
+    });
+    it('simple objects', function() {
+      var a = {
+        value: 1
+      };
+      var b = {
+        value: 1
+      };
+      expect(objectUtils.deepEqual(a, b)).to.true;
+    });
+    it('simple objects failed', function() {
+      var a = {
+        value: 1,
+        c: 1
+      };
+      var b = {
+        value: 1
+      };
+      expect(objectUtils.deepEqual(a, b)).to.false;
+    });
+    it('complex objects', function() {
+      var a = {
+        value: 1,
+        c: {
+          d: {
+            x: {
+              val: 1
+            }
+          }
+        }
+      };
+      var b = {
+        value: 1,
+        c: {
+          d: {
+            x: {
+              val: 1
+            }
+          }
+        }
+      };
+      expect(objectUtils.deepEqual(a, b)).to.true;
+    });
+    it('complex objects failed', function() {
+      var a = {
+        value: 1,
+        c: {
+          d: {
+            x: {
+              val: 1
+            }
+          }
+        }
+      };
+      var b = {
+        value: 1,
+        c: {
+          d: {
+            x: {
+              val: 2
+            }
+          }
+        }
+      };
+      expect(objectUtils.deepEqual(a, b)).to.false;
+    });
+    it('complex array', function() {
+      var a = [1,2,{a: 2}, 4, {b:{}}];
+      var b = [1,2,{a: 2}, 4, {b:{}}];
+      expect(objectUtils.deepEqual(a, b)).to.true;
+    });
+    it('complex array failed', function() {
+      var a = [1,3,{a: 2}, 4, {b:{}}];
+      var b = [1,2,{a: 2}, 4, {b:{}}];
+      expect(objectUtils.deepEqual(a, b)).to.false;
+    });
+    it('simple array', function() {
+      var a = [1,3];
+      var b = [1,3];
+      expect(objectUtils.deepEqual(a, b)).to.true;
+    });
+    it('simple array failed', function() {
+      var a = [3,1];
+      var b = [1,3];
+      expect(objectUtils.deepEqual(a, b)).to.false;
+    });
+  });
+
 });