hotfix/vmAvailabilitySetLimit: Fixed bug and added test case

collectors/azure/collector.js

@@ -192,6 +192,13 @@ var calls = {
 };
 
 var postcalls = {
+    availabilitySets:{
+        listByResourceGroup: {
+            reliesOnPath: 'resourceGroups.list',
+            properties: ['id'],
+            url: 'https://management.azure.com/{id}/providers/Microsoft.Compute/availabilitySets?api-version=2020-12-01'
+        }
+    },
     advancedThreatProtection: {
         get: {
             reliesOnPath: 'databaseAccounts.list',

plugins/azure/virtualmachines/vmAvailabilitySetLimit.js

@@ -8,7 +8,7 @@ module.exports = {
     more_info: 'Azure limits availability sets to certain numbers of resources. Exceeding those limits could prevent resources from launching.',
     link: 'https://docs.microsoft.com/en-us/azure/virtual-machines/windows/overview',
     recommended_action: 'Contact Azure support to increase the number of instances available',
-    apis: ['resourceGroups:list', 'availabilitySets:listBySubscription'],
+    apis: ['resourceGroups:list', 'availabilitySets:listByResourceGroup'],
     settings: {
         instance_limit_percentage_fail: {
             name: 'Instance Limit Percentage Fail',
@@ -36,49 +36,66 @@ module.exports = {
         var source = {};
         var locations = helpers.locations(settings.govcloud);
 
-        async.each(locations.availabilitySets, function(location, rcb){
+        async.each(locations.resourceGroups, function(location, rcb){
+            var resourceGroups = helpers.addSource(cache, source, 
+                ['resourceGroups', 'list', location]);
 
-            var availabilitySets = helpers.addSource(cache, source, 
-                ['availabilitySets', 'listBySubscription', location]);
+            if (!resourceGroups) return rcb();
 
-            if (!availabilitySets) return rcb();
-
-            if (availabilitySets.err || !availabilitySets.data) {
+            if (resourceGroups.err || !resourceGroups.data) {
                 helpers.addResult(results, 3, 
-                    'Unable to query Availability Sets: ' + helpers.addError(availabilitySets), location);
+                    'Unable to query Resource Groups: ' + helpers.addError(resourceGroups), location);
                 return rcb();
             }
 
-            if (!availabilitySets.data.length) {
-                helpers.addResult(results, 0, 'No existing Availability Sets', location);
+            if (!resourceGroups.data.length) {
+                helpers.addResult(results, 0, 'No existing Resource Groups', location);
                 return rcb();
             }
 
-            var limits = {
-                'max-instances': 200
-            };
+            async.each(resourceGroups.data, function(resourceGroup, scb){
+                var availabilitySets = helpers.addSource(cache, source, 
+                    ['availabilitySets', 'listByResourceGroup', location, resourceGroup.id]);
 
-            availabilitySets.data.forEach(availabilitySet => {
-                if (availabilitySet.virtualMachines) {
-                    var vmInstances = availabilitySet.virtualMachines.length;
-                } else {
-                    return;
+                if (!availabilitySets || availabilitySets.err || !availabilitySets.data) {
+                    helpers.addResult(results, 3, 
+                        'Unable to query Availability Sets: ' + helpers.addError(availabilitySets), location);
+                    return scb();
                 }
 
-                var percentage = Math.ceil((vmInstances / limits['max-instances']) * 100);
-                var returnMsg = 'Availability Set contains ' + vmInstances + ' of ' +
-                    limits['max-instances'] + ' (' + percentage + '%) available instances';
-
-                if (percentage >= config.instance_limit_percentage_fail) {
-                    helpers.addResult(results, 2, returnMsg, location, availabilitySet.id);
-                } else if (percentage >= config.instance_limit_percentage_warn) {
-                    helpers.addResult(results, 1, returnMsg, location, availabilitySet.id);
-                } else {
-                    helpers.addResult(results, 0, returnMsg, location, availabilitySet.id);
+                if (!availabilitySets.data.length) {
+                    helpers.addResult(results, 0, 'No existing Availability Sets', location);
+                    return scb();
                 }
-            });
 
-            rcb();
+                var limits = {
+                    'max-instances': 200
+                };
+
+                availabilitySets.data.forEach(availabilitySet => {
+                    if (availabilitySet.virtualMachines) {
+                        var vmInstances = availabilitySet.virtualMachines.length;
+                    } else {
+                        return;
+                    }
+
+                    var percentage = Math.ceil((vmInstances / limits['max-instances']) * 100);
+                    var returnMsg = 'Availability Set contains ' + vmInstances + ' of ' +
+                        limits['max-instances'] + ' (' + percentage + '%) available instances';
+
+                    if (percentage >= config.instance_limit_percentage_fail) {
+                        helpers.addResult(results, 2, returnMsg, location, availabilitySet.id);
+                    } else if (percentage >= config.instance_limit_percentage_warn) {
+                        helpers.addResult(results, 1, returnMsg, location, availabilitySet.id);
+                    } else {
+                        helpers.addResult(results, 0, returnMsg, location, availabilitySet.id);
+                    }
+                });
+
+                scb();
+            }, function(){
+                rcb();
+            });
         }, function(){
             callback(null, results, source);
         });

plugins/azure/virtualmachines/vmAvailabilitySetLimit.spec.js

@@ -0,0 +1,147 @@
+var expect = require('chai').expect;
+var vmAvailabilitySetLimit = require('./vmAvailabilitySetLimit');
+
+const resourceGroups = [
+    {
+        'id': '/subscriptions/123/resourceGroups/aqua-resource-group',
+        'name': 'aqua-resource-group',
+        'type': 'Microsoft.Resources/resourceGroups',
+        'location': 'eastus',
+        'tags': {},
+        'properties': {
+            'provisioningState': 'Succeeded'
+        }
+    }
+];
+
+const availabilitySets = [
+    {
+        'name': 'test-set',
+        'id': '/subscriptions/123/resourceGroups/aqua-resource-group/providers/Microsoft.Compute/availabilitySets/test-set',
+        'type': 'Microsoft.Compute/availabilitySets',
+        'location': 'eastus',
+        'tags': {},
+        'platformUpdateDomainCount': 5,
+        'platformFaultDomainCount': 2,
+        'virtualMachines': [
+            {
+                'id': '/subscriptions/123/resourceGroups/AQUA-RESOURCE-GROUP/providers/Microsoft.Compute/virtualMachines/test-vm-1'
+            }
+        ],
+        'sku': {
+            'name': 'Aligned'
+        }
+    }
+];
+
+const createCache = (resourceGroups, availabilitySets) => {
+    let group = {};
+    let set = {};
+    if (resourceGroups) {
+        group['data'] = resourceGroups;
+        if (resourceGroups.length && availabilitySets) {
+            set[resourceGroups[0].id] = {
+                data: availabilitySets
+            };
+        }
+    }
+    return {
+        resourceGroups: {
+            list: {
+                'eastus': group
+            }
+        },
+        availabilitySets: {
+            listByResourceGroup: {
+                'eastus': set
+            }
+        }
+    };
+};
+
+describe('vmAvailabilitySetLimit', function() {
+    describe('run', function() {
+        it('should give passing result if No existing resource groups', function(done) {
+            const cache = createCache([]);
+            vmAvailabilitySetLimit.run(cache, {}, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(0);
+                expect(results[0].message).to.include('No existing Resource Groups');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give unknown result if unable to query for resource groups', function(done) {
+            const cache = createCache();
+            vmAvailabilitySetLimit.run(cache, {}, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(3);
+                expect(results[0].message).to.include('Unable to query Resource Groups');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give passing result if No existing Availability Sets', function(done) {
+            const cache = createCache([resourceGroups[0]], []);
+            vmAvailabilitySetLimit.run(cache, {}, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(0);
+                expect(results[0].message).to.include('No existing Availability Sets');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give unknown result if unable to query for availability sets', function(done) {
+            const cache = createCache([resourceGroups[0]]);
+            vmAvailabilitySetLimit.run(cache, {}, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(3);
+                expect(results[0].message).to.include('Unable to query Availability Sets');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give passing result if vm instances percentage are below the limits', function(done) {
+            const cache = createCache([resourceGroups[0]], [availabilitySets[0]]);
+            vmAvailabilitySetLimit.run(cache, {}, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(0);
+                expect(results[0].message).to.include('Availability Set contains 1 of 200 (1%) available instances');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give failing results if number of vm instances has reached the fail limit', function(done) {
+            const cache = createCache([resourceGroups[0]], [availabilitySets[0]]);
+            const settings = {
+                instance_limit_percentage_fail: 1
+            };
+            vmAvailabilitySetLimit.run(cache, settings, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(2);
+                expect(results[0].message).to.include('Availability Set contains 1 of 200 (1%) available instances');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+
+        it('should give warn result if number of vm instances has reached the warn limit', function(done) {
+            const cache = createCache([resourceGroups[0]], [availabilitySets[0]]);
+            const settings = {
+                instance_limit_percentage_warn: 1
+            };
+            vmAvailabilitySetLimit.run(cache, settings, (err, results) => {
+                expect(results.length).to.equal(1);
+                expect(results[0].status).to.equal(1);
+                expect(results[0].message).to.include('Availability Set contains 1 of 200 (1%) available instances');
+                expect(results[0].region).to.equal('eastus');
+                done();
+            });
+        });
+    });
+});