Merge d79c549 into 4ee0dc3

BaseCollector.py

@@ -83,6 +83,14 @@ def get_vms(self, target):
         self.vms = request.json()
         return self.vms
 
+    def get_nsx_t_mgmt_cluster(self, target):
+        self.wait_for_inventory_data()
+        current_iteration = self.get_iteration()
+        url = "http://" + os.environ['INVENTORY'] + "/" + target + "/nsx_t_mgmt_cluster/{}".format(current_iteration)
+        request = requests.get(url)
+        self.nsx_t_mgmt_cluster = request.json()
+        return self.nsx_t_mgmt_cluster
+
     def get_iteration(self):
         request = requests.get(url="http://" + os.environ['INVENTORY'] + "/iteration")
         self.iteration = request.json()
@@ -134,6 +142,11 @@ def get_vms_by_target(self):
         self.target_vms = [vms_dict[uuid]['uuid'] for uuid in vms_dict]
         return self.target_vms
 
+    def get_nsx_t_mgmt_cluster_by_target(self):
+        nsx_t_resources_dict = self.get_nsx_t_mgmt_cluster(self.target)
+        self.target_nsx_t_mgmt_cluster = [nsx_t_resources_dict[uuid]['uuid'] for uuid in nsx_t_resources_dict]
+        return self.target_nsx_t_mgmt_cluster
+
     def get_project_ids_by_target(self):
         try:
             token = self.get_target_tokens()

InventoryBuilder.py

@@ -1,7 +1,7 @@
 from flask import Flask
 from gevent.pywsgi import WSGIServer
 from threading import Thread
-from resources.Resourceskinds import Vcenter
+from resources.Resourceskinds import Vcenter, NSX_T_Mgmt_Plane
 from tools.Vrops import Vrops
 import time
 import json
@@ -20,6 +20,7 @@ def __init__(self, atlas_config, port, sleep, timeout):
         self._user = os.environ["USER"]
         self._password = os.environ["PASSWORD"]
         self.vcenter_dict = dict()
+        self.nsx_t_dict = dict()
         self.target_tokens = dict()
         self.iterated_inventory = dict()
         self.vrops_collection_times = dict()
@@ -70,6 +71,10 @@ def datastores(target, iteration):
         def vms(target, iteration):
             return self.iterated_inventory[str(iteration)]['vms'][target]
 
+        @app.route('/<target>/nsx_t_mgmt_cluster/<int:iteration>', methods=['GET'])
+        def nsx_t_mgmt_cluster(target, iteration):
+            return self.iterated_inventory[str(iteration)]['nsx_t_resources'][target]
+
         @app.route('/iteration', methods=['GET'])
         def iteration():
             return_iteration = self.successful_iteration_list[-1]
@@ -169,6 +174,7 @@ def query_inventory_permanent(self):
             self.get_hosts()
             self.get_datastores()
             self.get_vms()
+            self.get_nsx_t_mgmt_cluster()
             if len(self.iterated_inventory[str(self.iteration)]['vcenters']) > 0:
                 self.successful_iteration_list.append(self.iteration)
             else:
@@ -190,37 +196,43 @@ def query_vrops(self, vrops, vrops_short_name):
 
         logger.info(f'##########  Collecting resources {vrops_short_name}... ##########')
 
-        vcenter = self.create_resource_objects(vrops, token)
+        vcenter = self.create_vcenter_objects(vrops, token)
         if not vcenter:
             return False
         self.vcenter_dict[vrops] = vcenter
+
+        nsx_t_adapter = self.create_nsx_t_objects(vrops, token)
+        if not nsx_t_adapter:
+            return False
+        self.nsx_t_dict[vrops] = nsx_t_adapter
+
         return True
 
-    def create_resource_objects(self, target: str, token: str) -> Vcenter:
+    def create_vcenter_objects(self, target: str, token: str):
         vrops = Vrops()
-        vcenter_name, vcenter_uuid = Vrops.get_adapter(vrops, target, token)
-        if not vcenter_name:
+        vcenter_adapter = Vrops.get_adapter(vrops, target, token, adapterkind="VMWARE")[0]
+        if not vcenter_adapter:
             return False
-        logger.debug(f'Collecting vcenter: {vcenter_name}')
+        logger.debug(f'Collecting vcenter: {vcenter_adapter["name"]}')
 
-        datacenter = Vrops.get_datacenter(vrops, target, token, [vcenter_uuid])
+        datacenter = Vrops.get_datacenter(vrops, target, token, [vcenter_adapter["uuid"]])
         cluster_and_ds = Vrops.get_cluster_and_datastores(vrops, target, token, [dc.get('uuid') for dc in datacenter])
 
         cluster = [cl for cl in cluster_and_ds if cl.get('resourcekind') == "ClusterComputeResource"]
         dss = [ds for ds in cluster_and_ds if ds.get('resourcekind') == "Datastore"]
 
         hosts = Vrops.get_hosts(vrops, target, token, [cl.get('uuid') for cl in cluster])
-        vms = Vrops.get_vms(vrops, target, token, [hs.get('uuid') for hs in hosts], vcenter_uuid)
+        vms = Vrops.get_vms(vrops, target, token, [hs.get('uuid') for hs in hosts], vcenter_adapter["uuid"])
 
-        vcenter = Vcenter(target, token, vcenter_uuid, vcenter_name)
+        vcenter = Vcenter(target, token, vcenter_adapter["uuid"], vcenter_adapter["name"])
         for dc in datacenter:
             vcenter.add_datacenter(dc)
         for dc_object in vcenter.datacenter:
             logger.debug(f'Collecting datacenter: {dc_object.name}')
             for ds in dss:
                 if ds.get('parent') == dc_object.uuid:
                     dc_object.add_datastore(ds)
-                    logger.debug(f'Collecting Datastore: {ds.get("name")}')
+                    logger.debug(f'Collecting datastore: {ds.get("name")}')
             for cl in cluster:
                 dc_object.add_cluster(cl)
             for cl_object in dc_object.clusters:
@@ -236,6 +248,26 @@ def create_resource_objects(self, target: str, token: str) -> Vcenter:
                             logger.debug(f'Collecting VM: {vm.get("name")}')
         return vcenter
 
+    def create_nsx_t_objects(self, target: str, token: str):
+        vrops = Vrops()
+        nsx_t_adapter = Vrops.get_adapter(vrops, target, token, adapterkind="NSXTAdapter")
+        if not nsx_t_adapter:
+            return False
+
+        nsx_t_mgmt_plane = NSX_T_Mgmt_Plane(target, token)
+        for adapter in nsx_t_adapter:
+            logger.debug(f'Collecting NSX-T adapter: {adapter.get("name")}')
+            nsx_t_mgmt_plane.add_adapter(adapter)
+
+        nsx_t_mgmt_cluster = Vrops.get_nsx_t_mgmt_cluster(vrops, target, token, [a.get("uuid") for a in nsx_t_adapter])
+
+        for adapter_object in nsx_t_mgmt_plane.adapter:
+            for mgmt_cluster in nsx_t_mgmt_cluster:
+                if mgmt_cluster.get('parent') == adapter_object.uuid:
+                    adapter_object.add_mgmt_cluster(mgmt_cluster)
+                    logger.debug(f'Collecting NSX-T management cluster: {mgmt_cluster.get("name")}')
+        return nsx_t_mgmt_plane
+
     def get_vcenters(self) -> dict:
         tree = dict()
         for vcenter_entry in self.vcenter_dict:
@@ -354,3 +386,21 @@ def get_vms(self) -> dict:
                             }
         self.iterated_inventory[str(self.iteration)]['vms'] = tree
         return tree
+
+    def get_nsx_t_mgmt_cluster(self) -> dict:
+        tree = dict()
+        for nsx_t_entry in self.nsx_t_dict:
+            nsx_t_mgmt_plane = self.nsx_t_dict[nsx_t_entry]
+            tree[nsx_t_mgmt_plane.target] = dict()
+            for nsx_t_adapter in nsx_t_mgmt_plane.adapter:
+                for mgmt_cluster in nsx_t_adapter.management_cluster:
+                    tree[nsx_t_mgmt_plane.target][mgmt_cluster.uuid] = {
+                        'uuid': mgmt_cluster.uuid,
+                        'name': mgmt_cluster.name,
+                        'nsx_t_adapter_name': nsx_t_adapter.name,
+                        'nsx_t_adapter_uuid': nsx_t_adapter.uuid,
+                        'target': nsx_t_mgmt_plane.target,
+                        'token': nsx_t_mgmt_plane.token,
+                    }
+        self.iterated_inventory[str(self.iteration)]['nsx_t_resources'] = tree
+        return tree

collectors/NSXTMmgtClusterStatsCollector.py

@@ -0,0 +1,16 @@
+from collectors.StatsCollector import StatsCollector
+
+
+class NSXTMmgtClusterStatsCollector(StatsCollector):
+
+    def __init__(self):
+        super().__init__()
+        self.vrops_entity_name = 'nsxt'
+        self.label_names = ['nsx_t_mgmt_cluster', 'nsx_t_adapter']
+
+    def get_resource_uuids(self):
+        return self.get_nsx_t_mgmt_cluster_by_target()
+
+    def set_labels(self, resource_id, project_ids):
+        return [self.nsx_t_mgmt_cluster[resource_id]['name'],
+                self.nsx_t_mgmt_cluster[resource_id]['nsx_t_adapter_name']] if resource_id else []

resources/Resourceskinds.py

@@ -80,3 +80,30 @@ def __init__(self, name, uuid):
         self.uuid = uuid
 
 
+class NSX_T_Mgmt_Plane:
+
+    def __init__(self, target, token):
+        self.target = target
+        self.token = token
+        self.adapter = list()
+
+    def add_adapter(self, adapter):
+        self.adapter.append(NSX_T_Adapter_Instance(adapter.get('name'), adapter.get('uuid')))
+
+
+class NSX_T_Adapter_Instance:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid
+        self.management_cluster = list()
+
+    def add_mgmt_cluster(self, mgmt_cluster):
+        self.management_cluster.append(NSX_T_ManagementCluster(mgmt_cluster.get('name'), mgmt_cluster.get('uuid')))
+
+
+class NSX_T_ManagementCluster:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid

tests/TestCollectors.py

@@ -22,13 +22,13 @@
 from collectors.ClusterStatsCollector import ClusterStatsCollector
 from collectors.VCenterStatsCollector import VCenterStatsCollector
 from collectors.VCenterPropertiesCollector import VCenterPropertiesCollector
+from collectors.NSXTMmgtClusterStatsCollector import NSXTMmgtClusterStatsCollector
 from prometheus_client.core import REGISTRY
 import unittest
 import random
 import http.client
 import os
 import time
-import importlib
 
 
 class TestCollectors(unittest.TestCase):
@@ -50,7 +50,8 @@ def test_collector_metrics(self):
         BaseCollector.get_target_tokens = MagicMock(
             return_value={'testhost.test': '2ed214d523-235f-h283-4566-6sf356124fd62::f234234-234'})
         Vrops.get_token = MagicMock(return_value=("2ed214d523-235f-h283-4566-6sf356124fd62::f234234-234", 200))
-        Vrops.get_adapter = MagicMock(return_value=("vcenter1", "3628-93a1-56e84634050814"))
+        Vrops.get_adapter = MagicMock(return_value=([{"name": "adapter1",
+                                                      "uuid": "3628-93a1-56e84634050814"}]))
         # test tool get_resources to create resource objects
 
         Vrops.get_datacenter = MagicMock(
@@ -63,6 +64,16 @@ def test_collector_metrics(self):
                           {'name': 'datacenter3', 'uuid': '7422-91h7-52s842060815',
                            'resourcekind': 'Datacenter',
                            'parent': '3628-93a1-56e84634050814'}])
+        Vrops.get_nsx_t_mgmt_cluster = MagicMock(
+            return_value=[{'name': 'nsx_t_mgmt_cluster1', 'uuid': '3628-93a1-56e84634050814',
+                           'resourcekind': 'ManagementCluster',
+                           'parent': '3628-93a1-56e84634050814'},
+                          {'name': 'nsx_t_mgmt_cluster2', 'uuid': '5628-9ba1-55e847050815',
+                           'resourcekind': 'ManagementCluster',
+                           'parent': '3628-93a1-56e84634050814'},
+                          {'name': 'nsx_t_mgmt_cluster3', 'uuid': '7422-91h7-52s842060815',
+                           'resourcekind': 'ManagementCluster',
+                           'parent': '3628-93a1-56e84634050814'}])
         Vrops.get_cluster_and_datastores = MagicMock(
             return_value=[{'name': 'cluster1', 'uuid': '3628-93a1-56e84634050814',
                            'resourcekind': 'ClusterComputeResource',

tests/collector_config.yaml

@@ -1,4 +1,5 @@
 default_collectors:
+    - 'NSXTMmgtClusterStatsCollector'
     - 'ClusterStatsCollector'
     - 'ClusterPropertiesCollector'
     - 'DatastoreStatsCollector'
@@ -280,3 +281,11 @@ VMStatsDefaultCollector:
     key: "guestfilesystem:/storage/db|capacity"
   - metric_suffix: "guestfilesystem_storage_db_percentage"
     key: "guestfilesystem:/storage/db|percentage"
+
+NSXTMmgtClusterStatsCollector:
+  - metric_suffix: "sys_capacity_distributed_firewall_rules_usage_count"
+    key: "System Capacity|Distributed Firewall Rules|UsageCount"
+  - metric_suffix: "sys_capacity_distributed_firewall_rules_usage_count_percentage"
+    key: "System Capacity|Distributed Firewall Rules|UsageCountPercentage"
+  - metric_suffix: "sys_capacity_distributed_firewall_rules_max_supported_count"
+    key: "System Capacity|Distributed Firewall Rules|MaxSupportedCount"