osi-dump 0.1.3.3.4.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

osi_dump/importer/flavor/openstack_flavor_importer.py

@@ -1,64 +1,64 @@
-import logging
-
-import concurrent
-
-from openstack.connection import Connection
-from openstack.compute.v2.flavor import Flavor as OSFlavor
-
-from osi_dump.importer.flavor.flavor_importer import FlavorImporter
-from osi_dump.model.flavor import Flavor
-
-logger = logging.getLogger(__name__)
-
-
-class OpenStackFlavorImporter(FlavorImporter):
-    def __init__(self, connection: Connection):
-        self.connection = connection
-
-    def import_flavors(self) -> list[Flavor]:
-        """Import flavors information from Openstack
-
-        Raises:
-            Exception: Raises exception if fetching flavor failed
-
-        Returns:
-            list[Instance]: _description_
-        """
-
-        logger.info(f"Importing flavors for {self.connection.auth['auth_url']}")
-
-        try:
-            osflavors: list[OSFlavor] = list(self.connection.list_flavors())
-        except Exception as e:
-            raise Exception(
-                f"Can not fetch flavors for {self.connection.auth['auth_url']}"
-            ) from e
-
-        flavors: list[Flavor] = []
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(self._get_flavor_info, osflavor)
-                for osflavor in osflavors
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                flavors.append(future.result())
-
-        logger.info(f"Imported flavors for {self.connection.auth['auth_url']}")
-
-        return flavors
-
-    def _get_flavor_info(self, flavor: OSFlavor) -> Flavor:
-
-        ret_flavor = Flavor(
-            flavor_id=flavor.id,
-            flavor_name=flavor.name,
-            ram=flavor.ram,
-            vcpus=flavor.vcpus,
-            disk=flavor.disk,
-            swap=flavor.swap,
-            public=flavor.is_public,
-            properties=flavor.extra_specs,
-        )
-
-        return ret_flavor
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.compute.v2.flavor import Flavor as OSFlavor
+
+from osi_dump.importer.flavor.flavor_importer import FlavorImporter
+from osi_dump.model.flavor import Flavor
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackFlavorImporter(FlavorImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_flavors(self) -> list[Flavor]:
+        """Import flavors information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching flavor failed
+
+        Returns:
+            list[Instance]: _description_
+        """
+
+        logger.info(f"Importing flavors for {self.connection.auth['auth_url']}")
+
+        try:
+            osflavors: list[OSFlavor] = list(self.connection.list_flavors())
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch flavors for {self.connection.auth['auth_url']}"
+            ) from e
+
+        flavors: list[Flavor] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_flavor_info, osflavor)
+                for osflavor in osflavors
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                flavors.append(future.result())
+
+        logger.info(f"Imported flavors for {self.connection.auth['auth_url']}")
+
+        return flavors
+
+    def _get_flavor_info(self, flavor: OSFlavor) -> Flavor:
+
+        ret_flavor = Flavor(
+            flavor_id=flavor.id,
+            flavor_name=flavor.name,
+            ram=flavor.ram,
+            vcpus=flavor.vcpus,
+            disk=flavor.disk,
+            swap=flavor.swap,
+            public=flavor.is_public,
+            properties=flavor.extra_specs,
+        )
+
+        return ret_flavor

osi_dump/importer/floating_ip/floating_ip_importer.py

@@ -1,9 +1,9 @@
-from abc import ABC, abstractmethod
-
-from osi_dump.model.floating_ip import FloatingIP
-
-
-class FloatingIPImporter(ABC):
-    @abstractmethod
-    def import_floating_ips(self) -> list[FloatingIP]:
-        pass
+from abc import ABC, abstractmethod
+
+from osi_dump.model.floating_ip import FloatingIP
+
+
+class FloatingIPImporter(ABC):
+    @abstractmethod
+    def import_floating_ips(self) -> list[FloatingIP]:
+        pass

osi_dump/importer/floating_ip/openstack_floating_ip_importer.py

@@ -1,68 +1,68 @@
-import logging
-
-import concurrent
-
-from openstack.connection import Connection
-from openstack.network.v2.floating_ip import FloatingIP as OSFloatingIP
-
-from osi_dump.importer.floating_ip.floating_ip_importer import FloatingIPImporter
-from osi_dump.model.floating_ip import FloatingIP
-
-logger = logging.getLogger(__name__)
-
-
-class OpenStackFloatingIPImporter(FloatingIPImporter):
-    def __init__(self, connection: Connection):
-        self.connection = connection
-
-    def import_floating_ips(self) -> list[FloatingIP]:
-        """Import instances information from Openstack
-
-        Raises:
-            Exception: Raises exception if fetching server failed
-
-        Returns:
-            list[Instance]: _description_
-        """
-
-        logger.info(f"Importing floating ips for {self.connection.auth['auth_url']}")
-
-        try:
-            osfloating_ips: list[OSFloatingIP] = list(
-                self.connection.list_floating_ips()
-            )
-        except Exception as e:
-            raise Exception(
-                f"Can not fetch floating IPs for {self.connection.auth['auth_url']}"
-            ) from e
-
-        floating_ips: list[FloatingIP] = []
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(self._get_floating_ip_info, osfloating_ip)
-                for osfloating_ip in osfloating_ips
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                floating_ips.append(future.result())
-
-        logger.info(f"Imported floating ips for {self.connection.auth['auth_url']}")
-
-        return floating_ips
-
-    def _get_floating_ip_info(self, floating_ip: OSFloatingIP) -> FloatingIP:
-
-        ret_floating_ip = FloatingIP(
-            floating_ip_id=floating_ip.id,
-            project_id=floating_ip.project_id,
-            floating_ip_address=floating_ip.floating_ip_address,
-            floating_network=floating_ip.floating_network_id,
-            fixed_ip_address=floating_ip.fixed_ip_address,
-            router_id=floating_ip.router_id,
-            port_id=floating_ip.port_id,
-            status=floating_ip.status,
-            created_at=floating_ip.created_at,
-            updated_at=floating_ip.updated_at,
-        )
-
-        return ret_floating_ip
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.network.v2.floating_ip import FloatingIP as OSFloatingIP
+
+from osi_dump.importer.floating_ip.floating_ip_importer import FloatingIPImporter
+from osi_dump.model.floating_ip import FloatingIP
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackFloatingIPImporter(FloatingIPImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_floating_ips(self) -> list[FloatingIP]:
+        """Import instances information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching server failed
+
+        Returns:
+            list[Instance]: _description_
+        """
+
+        logger.info(f"Importing floating ips for {self.connection.auth['auth_url']}")
+
+        try:
+            osfloating_ips: list[OSFloatingIP] = list(
+                self.connection.list_floating_ips()
+            )
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch floating IPs for {self.connection.auth['auth_url']}"
+            ) from e
+
+        floating_ips: list[FloatingIP] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_floating_ip_info, osfloating_ip)
+                for osfloating_ip in osfloating_ips
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                floating_ips.append(future.result())
+
+        logger.info(f"Imported floating ips for {self.connection.auth['auth_url']}")
+
+        return floating_ips
+
+    def _get_floating_ip_info(self, floating_ip: OSFloatingIP) -> FloatingIP:
+
+        ret_floating_ip = FloatingIP(
+            floating_ip_id=floating_ip.id,
+            project_id=floating_ip.project_id,
+            floating_ip_address=floating_ip.floating_ip_address,
+            floating_network=floating_ip.floating_network_id,
+            fixed_ip_address=floating_ip.fixed_ip_address,
+            router_id=floating_ip.router_id,
+            port_id=floating_ip.port_id,
+            status=floating_ip.status,
+            created_at=floating_ip.created_at,
+            updated_at=floating_ip.updated_at,
+        )
+
+        return ret_floating_ip

osi_dump/importer/hypervisor/hypervisor_importer.py

@@ -1,9 +1,9 @@
-from abc import ABC, abstractmethod
-
-from osi_dump.model.hypervisor import Hypervisor
-
-
-class HypervisorImporter(ABC):
-    @abstractmethod
-    def import_hypervisors(self) -> list[Hypervisor]:
-        pass
+from abc import ABC, abstractmethod
+
+from osi_dump.model.hypervisor import Hypervisor
+
+
+class HypervisorImporter(ABC):
+    @abstractmethod
+    def import_hypervisors(self) -> list[Hypervisor]:
+        pass

osi_dump/importer/hypervisor/openstack_hypervisor_importer.py

@@ -1,137 +1,137 @@
-import logging
-
-import concurrent
-
-from openstack.connection import Connection
-from openstack.compute.v2.hypervisor import Hypervisor as OSHypervisor
-from openstack.compute.v2.aggregate import Aggregate as OSAggregate
-
-from openstack.placement.v1._proxy import Proxy as PlacementProxy
-from openstack.placement.v1.resource_provider_inventory import ResourceProviderInventory
-
-from osi_dump.importer.hypervisor.hypervisor_importer import HypervisorImporter
-from osi_dump.model.hypervisor import Hypervisor
-
-from osi_dump.api.placement import get_usage
-
-logger = logging.getLogger(__name__)
-
-
-class OpenStackHypervisorImporter(HypervisorImporter):
-    def __init__(self, connection: Connection):
-        self.connection = connection
-
-    def import_hypervisors(self) -> list[Hypervisor]:
-        """Import hypervisors information from Openstack
-
-        Raises:
-            Exception: Raises exception if fetching hypervisor failed
-
-        Returns:
-            list[Hypervisor]: _description_
-        """
-        aggregates = list(self.connection.list_aggregates())
-
-        try:
-            oshypervisors: list[OSHypervisor] = list(
-                self.connection.compute.hypervisors(details=True, with_servers=True)
-            )
-
-        except Exception as e:
-            raise Exception(
-                f"Can not fetch hypervisor for {self.connection.auth['auth_url']}"
-            ) from e
-
-        hypervisors: list[Hypervisor] = []
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(self._get_hypervisor_info, hypervisor, aggregates)
-                for hypervisor in oshypervisors
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                hypervisors.append(future.result())
-
-        logger.info(f"Imported hypervisors for {self.connection.auth['auth_url']}")
-
-        return hypervisors
-
-
-    def _normalize_hypervisor_aggregate(self, hypervisors: list[Hypervisor]):
-        
-        aggregate_id_map = {
-
-        }
-
-        aggregates: list[list[dict]] = [
-
-        ]
-
-        for hypervisor in hypervisors:
-            aggregates.append(hypervisor.aggregates)
-
-    def _swap_element(array, i, j): 
-        array[i], array[j] = array[j], array[i]
-
-    def _get_hypervisor_info(
-        self, hypervisor: OSHypervisor, aggregates: list[OSAggregate]
-    ) -> Hypervisor:
-        aggregate_list, az = self._get_aggregates(hypervisor=hypervisor)
-
-        placement_proxy: PlacementProxy = self.connection.placement
-
-        rpi: ResourceProviderInventory = list(
-            placement_proxy.resource_provider_inventories(
-                resource_provider=hypervisor.id
-            )
-        )
-
-        usage_data = get_usage(self.connection, resource_provider_id=hypervisor.id)
-
-        vcpu = rpi[0]
-        memory = rpi[1]
-        disk = rpi[2]
-
-        ret_hypervisor = Hypervisor(
-            hypervisor_id=hypervisor.id,
-            hypervisor_type=hypervisor.hypervisor_type,
-            name=hypervisor.name,
-            state=hypervisor.state,
-            status=hypervisor.status,
-            local_disk_size=disk["max_unit"],
-            memory_size=memory["max_unit"] + memory["reserved"],
-            vcpus=vcpu["max_unit"],
-            vcpus_usage=usage_data["VCPU"],
-            memory_usage=usage_data["MEMORY_MB"],
-            local_disk_usage=usage_data["DISK_GB"],
-            vm_count=len(hypervisor.servers),
-            aggregates=aggregate_list,
-            availability_zone=az,
-        )
-
-        return ret_hypervisor
-
-    def _get_aggregates(self, hypervisor: OSHypervisor):
-        aggregates_ret = []
-
-        aggregates: OSAggregate = list(self.connection.list_aggregates())
-
-        az = None
-
-        for aggregate in aggregates:
-            if hypervisor.name in aggregate.hosts:
-                aggregates_ret.append(
-                    {
-                        "id": aggregate.id,
-                        "name": aggregate.name,
-                    }
-                )
-
-                if aggregate.availability_zone != None:
-                    az = aggregate.availability_zone
-
-        aggregates_ret = [
-            dict(sorted(aggregate.items())) for aggregate in aggregates_ret
-        ]
-
-        return aggregates_ret, az
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.compute.v2.hypervisor import Hypervisor as OSHypervisor
+from openstack.compute.v2.aggregate import Aggregate as OSAggregate
+
+from openstack.placement.v1._proxy import Proxy as PlacementProxy
+from openstack.placement.v1.resource_provider_inventory import ResourceProviderInventory
+
+from osi_dump.importer.hypervisor.hypervisor_importer import HypervisorImporter
+from osi_dump.model.hypervisor import Hypervisor
+
+from osi_dump.api.placement import get_usage
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackHypervisorImporter(HypervisorImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_hypervisors(self) -> list[Hypervisor]:
+        """Import hypervisors information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching hypervisor failed
+
+        Returns:
+            list[Hypervisor]: _description_
+        """
+        aggregates = list(self.connection.list_aggregates())
+
+        try:
+            oshypervisors: list[OSHypervisor] = list(
+                self.connection.compute.hypervisors(details=True, with_servers=True)
+            )
+
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch hypervisor for {self.connection.auth['auth_url']}"
+            ) from e
+
+        hypervisors: list[Hypervisor] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_hypervisor_info, hypervisor, aggregates)
+                for hypervisor in oshypervisors
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                hypervisors.append(future.result())
+
+        logger.info(f"Imported hypervisors for {self.connection.auth['auth_url']}")
+
+        return hypervisors
+
+
+    def _normalize_hypervisor_aggregate(self, hypervisors: list[Hypervisor]):
+        
+        aggregate_id_map = {
+
+        }
+
+        aggregates: list[list[dict]] = [
+
+        ]
+
+        for hypervisor in hypervisors:
+            aggregates.append(hypervisor.aggregates)
+
+    def _swap_element(array, i, j): 
+        array[i], array[j] = array[j], array[i]
+
+    def _get_hypervisor_info(
+        self, hypervisor: OSHypervisor, aggregates: list[OSAggregate]
+    ) -> Hypervisor:
+        aggregate_list, az = self._get_aggregates(hypervisor=hypervisor)
+
+        placement_proxy: PlacementProxy = self.connection.placement
+
+        rpi: ResourceProviderInventory = list(
+            placement_proxy.resource_provider_inventories(
+                resource_provider=hypervisor.id
+            )
+        )
+
+        usage_data = get_usage(self.connection, resource_provider_id=hypervisor.id)
+
+        vcpu = rpi[0]
+        memory = rpi[1]
+        disk = rpi[2]
+
+        ret_hypervisor = Hypervisor(
+            hypervisor_id=hypervisor.id,
+            hypervisor_type=hypervisor.hypervisor_type,
+            name=hypervisor.name,
+            state=hypervisor.state,
+            status=hypervisor.status,
+            local_disk_size=disk["max_unit"],
+            memory_size=memory["max_unit"] + memory["reserved"],
+            vcpus=vcpu["max_unit"],
+            vcpus_usage=usage_data["VCPU"],
+            memory_usage=usage_data["MEMORY_MB"],
+            local_disk_usage=usage_data["DISK_GB"],
+            vm_count=len(hypervisor.servers),
+            aggregates=aggregate_list,
+            availability_zone=az,
+        )
+
+        return ret_hypervisor
+
+    def _get_aggregates(self, hypervisor: OSHypervisor):
+        aggregates_ret = []
+
+        aggregates: OSAggregate = list(self.connection.list_aggregates())
+
+        az = None
+
+        for aggregate in aggregates:
+            if hypervisor.name in aggregate.hosts:
+                aggregates_ret.append(
+                    {
+                        "id": aggregate.id,
+                        "name": aggregate.name,
+                    }
+                )
+
+                if aggregate.availability_zone != None:
+                    az = aggregate.availability_zone
+
+        aggregates_ret = [
+            dict(sorted(aggregate.items())) for aggregate in aggregates_ret
+        ]
+
+        return aggregates_ret, az

osi_dump/importer/image/image_importer.py

@@ -1,9 +1,9 @@
-from abc import ABC, abstractmethod
-
-from osi_dump.model.image import Image
-
-
-class ImageImporter(ABC):
-    @abstractmethod
-    def import_images(self) -> list[Image]:
-        pass
+from abc import ABC, abstractmethod
+
+from osi_dump.model.image import Image
+
+
+class ImageImporter(ABC):
+    @abstractmethod
+    def import_images(self) -> list[Image]:
+        pass