osi-dump 0.1.1__py3-none-any.whl → 0.1.2.1__py3-none-any.whl

osi_dump/api/octavia.py

@@ -0,0 +1,17 @@
+from openstack.connection import Connection
+from openstack.identity.v3.service import Service
+
+
+def get_amphorae(connection: Connection, load_balancer_id: str) -> str | None:
+
+    octavia_endpoint = connection.endpoint_for(
+        service_type="octavia", interface="public"
+    )
+
+    url = f"{octavia_endpoint}/v2/octavia/amphorae"
+
+    response = connection.session.get(url)
+
+    data = response.json()
+
+    return data["usages"]

osi_dump/api/placement.py

@@ -0,0 +1,17 @@
+from openstack.connection import Connection
+from openstack.identity.v3.service import Service
+
+
+def get_usage(connection: Connection, resource_provider_id: str):
+
+    placement_endpoint = connection.endpoint_for(
+        service_type="placement", interface="public"
+    )
+
+    url = f"{placement_endpoint}/resource_providers/{resource_provider_id}/usages"
+
+    response = connection.session.get(url)
+
+    data = response.json()
+
+    return data["usages"]

osi_dump/batch_handler/flavor_batch_handler.py

@@ -0,0 +1,51 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.flavor.flavor_exporter import FlavorExporter
+from osi_dump.exporter.flavor.excel_flavor_exporter import (
+    ExcelFlavorExporter,
+)
+
+from osi_dump.importer.flavor.flavor_importer import FlavorImporter
+from osi_dump.importer.flavor.openstack_flavor_importer import (
+    OpenStackFlavorImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class FlavorBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[tuple[FlavorImporter, FlavorExporter]] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackFlavorImporter(connection)
+
+            sheet_name = f"{util.extract_hostname(connection.auth['auth_url'])}-flavor"
+            exporter = ExcelFlavorExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(self, importer: FlavorImporter, exporter: FlavorExporter):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+
+        for importer, exporter in self._importer_exporter_list:
+            try:
+
+                flavors = importer.import_flavors()
+
+                exporter.export_flavors(flavors=flavors)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/image_batch_handler.py

@@ -0,0 +1,51 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.image.image_exporter import ImageExporter
+from osi_dump.exporter.image.excel_image_exporter import (
+    ExcelImageExporter,
+)
+
+from osi_dump.importer.image.image_importer import ImageImporter
+from osi_dump.importer.image.openstack_image_importer import (
+    OpenStackImageImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class ImageBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[tuple[ImageImporter, ImageExporter]] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackImageImporter(connection)
+
+            sheet_name = f"{util.extract_hostname(connection.auth['auth_url'])}-image"
+            exporter = ExcelImageExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(self, importer: ImageImporter, exporter: ImageExporter):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+
+        for importer, exporter in self._importer_exporter_list:
+            try:
+
+                images = importer.import_images()
+
+                exporter.export_images(images=images)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/load_balancer_batch_handler.py

@@ -0,0 +1,61 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.load_balancer.load_balancer_exporter import (
+    LoadBalancerExporter,
+)
+from osi_dump.exporter.load_balancer.excel_load_balancer_exporter import (
+    ExcelLoadBalancerExporter,
+)
+
+from osi_dump.importer.load_balancer.load_balancer_importer import (
+    LoadBalancerImporter,
+)
+from osi_dump.importer.load_balancer.openstack_load_balancer_importer import (
+    OpenStackLoadBalancerImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class LoadBalancerBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[
+            tuple[LoadBalancerImporter, LoadBalancerExporter]
+        ] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackLoadBalancerImporter(connection)
+
+            sheet_name = (
+                f"{util.extract_hostname(connection.auth['auth_url'])}-load_balancer"
+            )
+            exporter = ExcelLoadBalancerExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(
+        self, importer: LoadBalancerImporter, exporter: LoadBalancerExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+
+        for importer, exporter in self._importer_exporter_list:
+            try:
+
+                load_balancers = importer.import_load_balancers()
+
+                exporter.export_load_balancers(load_balancers=load_balancers)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/role_assignment_batch_handler.py

@@ -0,0 +1,61 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.role_assignment.role_assignment_exporter import (
+    RoleAssignmentExporter,
+)
+from osi_dump.exporter.role_assignment.excel_role_assignment_exporter import (
+    ExcelRoleAssignmentExporter,
+)
+
+from osi_dump.importer.role_assignment.role_assignment_importer import (
+    RoleAssignmentImporter,
+)
+from osi_dump.importer.role_assignment.openstack_role_assignment_importer import (
+    OpenStackRoleAssignmentImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class RoleAssignmentBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[
+            tuple[RoleAssignmentImporter, RoleAssignmentExporter]
+        ] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackRoleAssignmentImporter(connection)
+
+            sheet_name = (
+                f"{util.extract_hostname(connection.auth['auth_url'])}-role_assignment"
+            )
+            exporter = ExcelRoleAssignmentExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(
+        self, importer: RoleAssignmentImporter, exporter: RoleAssignmentExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+
+        for importer, exporter in self._importer_exporter_list:
+            try:
+
+                role_assignments = importer.import_role_assignments()
+
+                exporter.export_role_assignments(role_assignments=role_assignments)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/cli.py

@@ -8,9 +8,16 @@ import typer
 
 from typing_extensions import Annotated
 
+from osi_dump.batch_handler.load_balancer_batch_handler import LoadBalancerBatchHandler
+from osi_dump.batch_handler.role_assignment_batch_handler import (
+    RoleAssignmentBatchHandler,
+)
+
 app = typer.Typer()
 
 
+from osi_dump.batch_handler.flavor_batch_handler import FlavorBatchHandler
+from osi_dump.batch_handler.image_batch_handler import ImageBatchHandler
 from osi_dump.batch_handler.volume_batch_handler import VolumeBatchHandler
 from osi_dump.os_connection.get_connections import get_connections
 
@@ -76,6 +83,46 @@ def _hypervisor(connections, output_path: str):
     hypervisor_batch_handler.process()
 
 
+def _image(connections, output_path: str):
+    image_batch_handler = ImageBatchHandler()
+
+    image_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    image_batch_handler.process()
+
+
+def _flavor(connections, output_path: str):
+    flavor_batch_handler = FlavorBatchHandler()
+
+    flavor_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    flavor_batch_handler.process()
+
+
+def _role_assignment(connections, output_path: str):
+    _role_assignment_batch_handler = RoleAssignmentBatchHandler()
+
+    _role_assignment_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    _role_assignment_batch_handler.process()
+
+
+def _load_balancer(connections, output_path: str):
+    _load_balancer_batch_handler = LoadBalancerBatchHandler()
+
+    _load_balancer_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    _load_balancer_batch_handler.process()
+
+
 def inner_main(file_path: str, output_path: str):
 
     logger = logging.getLogger(__name__)
@@ -92,6 +139,13 @@ def inner_main(file_path: str, output_path: str):
 
     _project(connections=connections, output_path=output_path)
 
+    _image(connections=connections, output_path=output_path)
+
+    _flavor(connections=connections, output_path=output_path)
+
+    _role_assignment(connections=connections, output_path=output_path)
+
+    _load_balancer(connections=connections, output_path=output_path)
     util.excel_autosize_column(output_path)
 
     util.excel_sort_sheet(output_path)
@@ -141,6 +195,9 @@ Path of the output file, will override if file already exists
         level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
     )
 
+    # Suppress pool limit warning will investigate later
+    logging.getLogger("urllib3").propagate = False
+
     logger = logging.getLogger(__name__)
 
     if util.validate_dir_path(file_path=output_path) is False:

osi_dump/exporter/flavor/excel_flavor_exporter.py

@@ -0,0 +1,30 @@
+import logging
+
+
+import pandas as pd
+
+
+from osi_dump.exporter.flavor.flavor_exporter import FlavorExporter
+
+from osi_dump.model.flavor import Flavor
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelFlavorExporter(FlavorExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_flavors(self, flavors: list[Flavor]):
+        df = pd.json_normalize([flavor.model_dump() for flavor in flavors])
+
+        logger.info(f"Exporting flavors for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported flavors for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting floating ips for {self.sheet_name} error: {e}")

osi_dump/exporter/flavor/flavor_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class FlavorExporter(ABC):
+    @abstractmethod
+    def export_flavors(self, flavors, output_file: str):
+        pass

osi_dump/exporter/image/excel_image_exporter.py

@@ -0,0 +1,28 @@
+import pandas as pd
+
+import logging
+
+
+from osi_dump import util
+from osi_dump.exporter.image.image_exporter import ImageExporter
+
+from osi_dump.model.image import Image
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelImageExporter(ImageExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_images(self, images: list[Image]):
+        df = pd.json_normalize([image.model_dump() for image in images])
+
+        logger.info(f"Exporting images for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported images for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting images for {self.sheet_name} error: {e}")

osi_dump/exporter/image/image_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class ImageExporter(ABC):
+    @abstractmethod
+    def export_images(self, images, output_file: str):
+        pass

osi_dump/exporter/load_balancer/excel_load_balancer_exporter.py

@@ -0,0 +1,33 @@
+import pandas as pd
+
+import logging
+
+
+from osi_dump import util
+
+from osi_dump.exporter.load_balancer.load_balancer_exporter import (
+    LoadBalancerExporter,
+)
+
+from osi_dump.model.load_balancer import LoadBalancer
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelLoadBalancerExporter(LoadBalancerExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_load_balancers(self, load_balancers: list[LoadBalancer]):
+        df = pd.json_normalize(
+            [load_balancer.model_dump() for load_balancer in load_balancers]
+        )
+
+        logger.info(f"Exporting load_balancers for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported load_balancers for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting load_balancers for {self.sheet_name} error: {e}")

osi_dump/exporter/load_balancer/load_balancer_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class LoadBalancerExporter(ABC):
+    @abstractmethod
+    def export_load_balancers(self, load_balancers, output_file: str):
+        pass

osi_dump/exporter/role_assignment/excel_role_assignment_exporter.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+import logging
+
+
+from osi_dump import util
+
+from osi_dump.exporter.role_assignment.role_assignment_exporter import (
+    RoleAssignmentExporter,
+)
+
+from osi_dump.model.role_assignment import RoleAssignment
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelRoleAssignmentExporter(RoleAssignmentExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_role_assignments(self, role_assignments: list[RoleAssignment]):
+        df = pd.json_normalize(
+            [role_assignment.model_dump() for role_assignment in role_assignments]
+        )
+
+        logger.info(f"Exporting role_assignments for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported role_assignments for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(
+                f"Exporting role_assignments for {self.sheet_name} error: {e}"
+            )

osi_dump/exporter/role_assignment/role_assignment_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class RoleAssignmentExporter(ABC):
+    @abstractmethod
+    def export_role_assignments(self, role_assignments, output_file: str):
+        pass

osi_dump/importer/flavor/flavor_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.flavor import Flavor
+
+
+class FlavorImporter(ABC):
+    @abstractmethod
+    def import_flavors(self) -> list[Flavor]:
+        pass

osi_dump/importer/flavor/openstack_flavor_importer.py

@@ -0,0 +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

osi_dump/importer/hypervisor/openstack_hypervisor_importer.py

@@ -11,6 +11,8 @@ from openstack.placement.v1.resource_provider_inventory import ResourceProviderI
 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__)
 
 
@@ -31,7 +33,9 @@ class OpenStackHypervisorImporter(HypervisorImporter):
         logger.info(f"Importing hypervisors for {self.connection.auth['auth_url']}")
 
         try:
-            oshypervisors: list[OSHypervisor] = list(self.connection.list_hypervisors())
+            oshypervisors: list[OSHypervisor] = list(
+                self.connection.compute.hypervisors(details=True)
+            )
         except Exception as e:
             raise Exception(
                 f"Can not fetch hypervisor for {self.connection.auth['auth_url']}"
@@ -61,6 +65,14 @@ class OpenStackHypervisorImporter(HypervisorImporter):
             )
         )
 
+        servers = list(
+            self.connection.compute.servers(
+                details=False, all_project=True, hypervisor=hypervisor.id
+            )
+        )
+
+        usage_data = get_usage(self.connection, resource_provider_id=hypervisor.id)
+
         vcpu = rpi[0]
         memory = rpi[1]
         disk = rpi[2]
@@ -73,7 +85,11 @@ class OpenStackHypervisorImporter(HypervisorImporter):
             status=hypervisor.status,
             local_disk_size=disk["max_unit"],
             memory_size=memory["max_unit"] + memory["reserved"],
-            vpus=vcpu["max_unit"],
+            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(servers),
         )
 
         return ret_hypervisor

osi_dump/importer/image/image_importer.py

@@ -0,0 +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

osi_dump/importer/image/openstack_image_importer.py

@@ -0,0 +1,77 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.image.v2.image import Image as OSImage
+
+from osi_dump.importer.image.image_importer import ImageImporter
+from osi_dump.model.image import Image
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackImageImporter(ImageImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_images(self) -> list[Image]:
+        """Import instances information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching server failed
+
+        Returns:
+            list[Instance]: _description_
+        """
+
+        logger.info(f"Importing images for {self.connection.auth['auth_url']}")
+
+        try:
+
+            os_images: list[OSImage] = list(self.connection.list_images(show_all=True))
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch images for {self.connection.auth['auth_url']}"
+            ) from e
+
+        images: list[OSImage] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_image_info, image) for image in os_images
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                images.append(future.result())
+
+        logger.info(f"Imported images for {self.connection.auth['auth_url']}")
+
+        return images
+
+    def _get_image_info(self, os_image: OSImage) -> Image:
+
+        properties: dict = os_image.properties
+
+        properties.pop("owner_specified.openstack.md5", None)
+        properties.pop("owner_specified.openstack.sha256", None)
+        properties.pop("owner_specified.openstack.object", None)
+        properties.pop("stores", None)
+
+        image = Image(
+            image_id=os_image.id,
+            disk_format=os_image.disk_format,
+            min_disk=os_image.min_disk,
+            min_ram=os_image.min_ram,
+            image_name=os_image.name,
+            owner=os_image.owner,
+            properties=os_image.properties,
+            protected=os_image.is_protected,
+            status=os_image.status,
+            size=os_image.size,
+            virtual_size=os_image.virtual_size,
+            visibility=os_image.visibility,
+            created_at=os_image.created_at,
+            updated_at=os_image.updated_at,
+        )
+
+        return image

osi_dump/importer/load_balancer/load_balancer_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.load_balancer import LoadBalancer
+
+
+class LoadBalancerImporter(ABC):
+    @abstractmethod
+    def import_load_balancers(self) -> list[LoadBalancer]:
+        pass

osi_dump/importer/load_balancer/openstack_load_balancer_importer.py

@@ -0,0 +1,65 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+
+from openstack.load_balancer.v2.load_balancer import LoadBalancer as OSLoadBalancer
+
+from osi_dump.importer.load_balancer.load_balancer_importer import (
+    LoadBalancerImporter,
+)
+from osi_dump.model.load_balancer import LoadBalancer
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackLoadBalancerImporter(LoadBalancerImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_load_balancers(self) -> list[LoadBalancer]:
+        """Import load_balancers information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching load_balancer failed
+
+        Returns:
+            list[LoadBalancer]: _description_
+        """
+
+        logger.info(f"Importing load_balancers for {self.connection.auth['auth_url']}")
+
+        try:
+            osload_balancers: list[OSLoadBalancer] = list(
+                self.connection.network.load_balancers()
+            )
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch load_balancers for {self.connection.auth['auth_url']}"
+            ) from e
+
+        load_balancers: list[LoadBalancer] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_load_balancer_info, load_balancer)
+                for load_balancer in osload_balancers
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                load_balancers.append(future.result())
+
+        logger.info(f"Imported load_balancers for {self.connection.auth['auth_url']}")
+
+        return load_balancers
+
+    def _get_load_balancer_info(self, load_balancer: OSLoadBalancer) -> LoadBalancer:
+
+        load_balancer_ret = LoadBalancer(
+            id=load_balancer.id,
+            load_balancer_name=load_balancer.name,
+            status=load_balancer.operating_status,
+            project_id=load_balancer.project_id,
+        )
+
+        return load_balancer_ret

osi_dump/importer/project/openstack_project_importer.py

@@ -49,12 +49,39 @@ class OpenStackProjectImporter(ProjectImporter):
         return projects
 
     def _get_project_info(self, project: OSProject) -> Project:
+
+        try:
+            compute_quotas = self.connection.compute.get_quota_set(
+                project.id, usage=True
+            )
+        except Exception as e:
+            logger.warning(f"Get compute quotas failed for {project.id} error: {e}")
+
+        try:
+            storage_quotas = self.connection.block_storage.get_quota_set(
+                project.id, usage=True
+            )
+        except Exception as e:
+            logger.warning(f"Get storage quotas failed for {project.id} error: {e}")
+
         project_ret = Project(
             project_id=project.id,
             project_name=project.name,
             domain_id=project.domain_id,
             enabled=project.is_enabled,
             parent_id=project.parent_id,
+            usage_instance=compute_quotas.usage["instances"],
+            quota_instance=compute_quotas.instances,
+            usage_ram=compute_quotas.usage["ram"],
+            quota_ram=compute_quotas.ram,
+            usage_vcpu=compute_quotas.usage["cores"],
+            quota_vcpu=compute_quotas.cores,
+            usage_volume=storage_quotas.usage["volumes"],
+            quota_volume=storage_quotas.volumes,
+            usage_snapshot=storage_quotas.usage["snapshots"],
+            quota_snapshot=storage_quotas.snapshots,
+            usage_storage=storage_quotas.usage["gigabytes"],
+            quota_storage=storage_quotas.gigabytes,
         )
 
         return project_ret

osi_dump/importer/role_assignment/openstack_role_assignment_importer.py

@@ -0,0 +1,83 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.identity.v3.role_assignment import RoleAssignment as OSRoleAssignment
+
+from osi_dump.importer.role_assignment.role_assignment_importer import (
+    RoleAssignmentImporter,
+)
+from osi_dump.model.role_assignment import RoleAssignment
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackRoleAssignmentImporter(RoleAssignmentImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_role_assignments(self) -> list[RoleAssignment]:
+        """Import role_assignments information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching role_assignment failed
+
+        Returns:
+            list[RoleAssignment]: _description_
+        """
+
+        logger.info(
+            f"Importing role_assignments for {self.connection.auth['auth_url']}"
+        )
+
+        try:
+            osrole_assignments: list[OSRoleAssignment] = list(
+                self.connection.identity.role_assignments()
+            )
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch role_assignments for {self.connection.auth['auth_url']}"
+            ) from e
+
+        role_assignments: list[RoleAssignment] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_role_assignment_info, role_assignment)
+                for role_assignment in osrole_assignments
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                role_assignments.append(future.result())
+
+        logger.info(f"Imported role_assignments for {self.connection.auth['auth_url']}")
+
+        return role_assignments
+
+    def _get_role_assignment_info(
+        self, role_assignment: OSRoleAssignment
+    ) -> RoleAssignment:
+
+        user_name = None
+        role_name = None
+
+        try:
+            role_name = self.connection.identity.get_role(
+                role_assignment.role["id"]
+            ).name
+            user_name = self.connection.identity.get_user(
+                role_assignment.user["id"]
+            ).name
+
+        except Exception as e:
+            logger.warning("Can not get role name or user name")
+
+        role_assignment_ret = RoleAssignment(
+            user_id=role_assignment.user["id"],
+            user_name=user_name,
+            role_id=role_assignment.role["id"],
+            role_name=role_name,
+            scope=role_assignment.scope,
+        )
+
+        return role_assignment_ret

osi_dump/importer/role_assignment/role_assignment_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.role_assignment import RoleAssignment
+
+
+class RoleAssignmentImporter(ABC):
+    @abstractmethod
+    def import_role_assignments(self) -> list[RoleAssignment]:
+        pass

osi_dump/importer/volume/openstack_volume_importer.py

@@ -52,6 +52,19 @@ class OpenStackVolumeImporter(VolumeImporter):
 
     def _get_volume_info(self, volume: OSVolume) -> Volume:
 
+        snapshots = []
+        try:
+            snapshots = list(
+                self.connection.block_storage.snapshots(
+                    details=False, all_projects=True, volume_id=volume.id
+                )
+            )
+
+            snapshots = [snapshot["id"] for snapshot in snapshots]
+
+        except Exception as e:
+            logger.warning(f"Fetching snapshots failed for {volume.id} error: {e}")
+
         ret_volume = Volume(
             volume_id=volume.id,
             project_id=volume.project_id,
@@ -59,6 +72,7 @@ class OpenStackVolumeImporter(VolumeImporter):
             attachments=[att["server_id"] for att in volume.attachments],
             type=volume.volume_type,
             size=volume.size,
+            snapshots=snapshots,
             updated_at=volume.updated_at,
             created_at=volume.created_at,
         )

osi_dump/model/flavor.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Flavor(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    flavor_id: str
+
+    flavor_name: str
+
+    properties: Optional[dict]
+
+    ram: int
+    vcpus: int
+    disk: int
+    swap: Optional[int]
+
+    public: bool

osi_dump/model/hypervisor.py

@@ -7,6 +7,14 @@ class Hypervisor(BaseModel):
     name: str
     state: str
     status: str
-    local_disk_size: int
+
+    vcpus: int
+    vcpus_usage: int
+
     memory_size: int
-    vpus: int
+    memory_usage: int
+
+    local_disk_usage: int
+    local_disk_size: int
+
+    vm_count: int

osi_dump/model/image.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Image(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    image_id: str
+
+    disk_format: str
+    min_disk: int
+    min_ram: int
+    image_name: Optional[str]
+    owner: str
+
+    properties: Optional[dict]
+
+    protected: bool
+    status: str
+    size: int
+    virtual_size: int
+    visibility: str
+
+    created_at: str
+    updated_at: str

osi_dump/model/load_balancer.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class LoadBalancer(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    id: str
+
+    load_balancer_name: Optional[str]
+
+    status: str
+
+    # amphora_id: Optional[str]
+
+    project_id: Optional[str]

osi_dump/model/project.py

@@ -11,3 +11,21 @@ class Project(BaseModel):
     domain_id: Optional[str]
     enabled: bool
     parent_id: Optional[str]
+
+    usage_instance: Optional[int]
+    quota_instance: Optional[int]
+
+    usage_vcpu: Optional[int]
+    quota_vcpu: Optional[int]
+
+    usage_ram: Optional[int]
+    quota_ram: Optional[int]
+
+    usage_volume: Optional[int]
+    quota_volume: Optional[int]
+
+    usage_snapshot: Optional[int]
+    quota_snapshot: Optional[int]
+
+    usage_storage: Optional[int]
+    quota_storage: Optional[int]

osi_dump/model/role_assignment.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class RoleAssignment(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    user_id: str
+
+    user_name: Optional[str]
+
+    role_id: str
+
+    role_name: Optional[str]
+
+    scope: Optional[dict]

osi_dump/model/volume.py

@@ -17,5 +17,7 @@ class Volume(BaseModel):
     type: str
     size: int
 
+    snapshots: Optional[list[str]]
+
     updated_at: str
     created_at: str

osi_dump/os_connection/get_connections.py

@@ -33,7 +33,6 @@ def get_connections(file_path) -> list[Connection]:
                 password=auth.password,
                 project_domain_name=auth.project_domain_name,
                 user_domain_name=auth.user_domain_name,
-                timeout=TIMEOUT_SECOND,
             )
 
             connections.append(connection)

{osi_dump-0.1.1.dist-info → osi_dump-0.1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osi-dump
-Version: 0.1.1
+Version: 0.1.2.1
 Summary: OpenStack instances information dump tool
 Author: TVKain
 License: Apache-2.0

{osi_dump-0.1.1.dist-info → osi_dump-0.1.2.1.dist-info}/RECORD

@@ -1,52 +1,87 @@
 osi_dump/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/__main__.py,sha256=fCVTLFipB-P0872_4j7iOJNNosOMBj3YdHr8TH_fhRY,71
-osi_dump/cli.py,sha256=cTOQA_thCt1ON5eQ-gTA_hFUSN5uPgFPDoOttpyuTNg,3605
+osi_dump/cli.py,sha256=5sFtsS91Em26PmziWybKFW7bxnfRompH-1UTnWIKGkc,5425
+osi_dump/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/api/octavia.py,sha256=rT6d10OCQRdMnqvZTlW1gRMe1vOk8Rgct58oUIvDoyg,433
+osi_dump/api/placement.py,sha256=9yADLulo1HfUnPLE7IJt4ZY8e2jRTaoeV4J4MMiKCew,455
 osi_dump/batch_handler/__init__.py,sha256=wsiE42GCjbKgXBzpiahWEDF_-IXCKzr6PyrLn0oEKSc,288
+osi_dump/batch_handler/flavor_batch_handler.py,sha256=Cxf-rkuW5MrrOyiKi9N3InsdDGku7Bf0CAaPNhhM0hE,1589
 osi_dump/batch_handler/floating_ip_batch_handler.py,sha256=bEkT4BRi85qir-a1i7eEI_arA0LENq1gD6xHj8IdXu0,1771
 osi_dump/batch_handler/hypervisor_batch_handler.py,sha256=vkv6SAx1arPNVvFJ6RyvbJjC2F2Hes9km7dwhL4NJDY,1755
+osi_dump/batch_handler/image_batch_handler.py,sha256=aGF_jnHXuBc7IRFoLLCrSFD8h4TP0g98T_NtBXkZjd4,1564
 osi_dump/batch_handler/instance_batch_handler.py,sha256=tiHAdhH76BT9-ymnTmTr962cMUTqpPpAQyPSePKEgSM,1761
+osi_dump/batch_handler/load_balancer_batch_handler.py,sha256=Y8K5raUPX-ZtIRE9G0rgVBP9WsxKpqN3wv6eDYmXau4,1839
 osi_dump/batch_handler/project_batch_handler.py,sha256=uMHx_s-Z4tO1MBah5X-T5d6tLr0qUJuPIR_7RHJ64ck,1626
+osi_dump/batch_handler/role_assignment_batch_handler.py,sha256=x0LuRIyaBQq17aDznXqLxtZOPj79ufGz7TKFSM63vMA,1889
 osi_dump/batch_handler/volume_batch_handler.py,sha256=UAU34FZD8XkJkmlr4Idk4NgFBzjD52PxekJDgV1ekG0,1569
 osi_dump/exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/exporter/flavor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/exporter/flavor/excel_flavor_exporter.py,sha256=_wNVToj0FsIkaLbqn7-TWETrtUftBM1Pjr-0WaBJtBI,876
+osi_dump/exporter/flavor/flavor_exporter.py,sha256=-zQ8776yk7vHpiZUOcX61V8KxA40AAq8foV7fD0i1g0,155
 osi_dump/exporter/floating_ip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/exporter/floating_ip/excel_floating_ip_exporter.py,sha256=Bn1yZTvZ8dP3EhVHW-Pr4O9TC2Cz2RbJaz_vRE66xTQ,975
 osi_dump/exporter/floating_ip/floating_ip_exporter.py,sha256=5qh4xS6m1Gfu2N3WcfkEu6U38qtc6oLWAsnNhSwXTCo,169
 osi_dump/exporter/hypervisor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/exporter/hypervisor/excel_hypervisor_exporter.py,sha256=VhZoVjqCky5Sxvx0R9kxj-7O4tLTaPZKVqxyvqe1YLY,964
 osi_dump/exporter/hypervisor/hypervisor_exporter.py,sha256=HS3U-M-iv-ixNLfkGoaGdjdgHXXTBAjgtWQ_OhVY2xQ,167
+osi_dump/exporter/image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/exporter/image/excel_image_exporter.py,sha256=S_9UScZKI4N8xe8oXjNfnV2Eh7_llg7tOPR7H0hGVnA,853
+osi_dump/exporter/image/image_exporter.py,sha256=7sNugBJDIDHjW_J9DCPgonIIGvD7xrjb5ofK195xNfM,152
 osi_dump/exporter/instance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/exporter/instance/excel_instance_exporter.py,sha256=8WTv3RDOdUkumyWzwUK4KAZCnnq9P2yKi5TC091I9fs,931
 osi_dump/exporter/instance/instance_exporter.py,sha256=5CuKKvTa5S2_Ds7fap6tle4go9pOFmQ5VEf6O7tjwBo,161
+osi_dump/exporter/load_balancer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/exporter/load_balancer/excel_load_balancer_exporter.py,sha256=BM3dzGL7UAug1v3Re04RBowOLGvHwc6mc0gsTfRJJwo,1008
+osi_dump/exporter/load_balancer/load_balancer_exporter.py,sha256=Z5uvEKz1UG_dpAw5KVh-IX5PWLzlPt7pV9773bkgjXs,175
 osi_dump/exporter/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/exporter/project/excel_project_exporter.py,sha256=2U3Tvn_Bk4xEQk3Tmh-oj5WXAG1bfxI6m7WVPF1upQw,916
 osi_dump/exporter/project/project_exporter.py,sha256=q3VAmtmBP4iq9YEW9Eescm3vjAVM4Ev3BDjzkGz9Pgo,158
+osi_dump/exporter/role_assignment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/exporter/role_assignment/excel_role_assignment_exporter.py,sha256=CvMmueVclc22A7BPx8qR2-zXyr6FptI31bMHtyih2CA,1070
+osi_dump/exporter/role_assignment/role_assignment_exporter.py,sha256=MmqFhhF7HWFoULNdDPt8yuW0GZmDxV262iEnLkLKw1s,181
 osi_dump/exporter/volume/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/exporter/volume/excel_volume_exporter.py,sha256=BhesTGXMQF3BAwHgJMYfnxFgHxZo7TKPePG8q9T8ONI,865
 osi_dump/exporter/volume/volume_exporter.py,sha256=YoPvytC0ctWeWwVcG6pb0XwkF4N0QcGAoUHa3QldkEg,155
+osi_dump/importer/flavor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/importer/flavor/flavor_importer.py,sha256=IfU2L8N8EO4eESnEDirwe9U-GXSTuTcsdrlDxD95tcQ,186
+osi_dump/importer/flavor/openstack_flavor_importer.py,sha256=y3uFCls7H-l1tu11T_PaEoWghhdxINsf7baRAShXC1w,1876
 osi_dump/importer/floating_ip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/importer/floating_ip/floating_ip_importer.py,sha256=2_lCZYF-r2dgdL4YzwsJPudDLbRBsSPi7Wt4jS0INiI,208
 osi_dump/importer/floating_ip/openstack_floating_ip_importer.py,sha256=xuALHyiyb4LdRgFN0hZvOx0pImKpGsLUtPWW_1q52gc,2286
 osi_dump/importer/hypervisor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/importer/hypervisor/hypervisor_importer.py,sha256=JuoJBltqFYhH-Ql9TLUPHX2YurS0JFV7Augrc6bDJ5Q,206
-osi_dump/importer/hypervisor/openstack_hypervisor_importer.py,sha256=9Y-OsjfOzCKi_DijlHeMv9sgsD_oWB_YXW_lDtVeahM,2567
+osi_dump/importer/hypervisor/openstack_hypervisor_importer.py,sha256=8EP99VPMrm4RUSHDbMmiuZeDOnwY17RLtJGotHd6ETs,3093
+osi_dump/importer/image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/importer/image/image_importer.py,sha256=6zwAMnS58S2HGwARwebqf4VE9IBQBv5Ot6nmcn9H4fY,181
+osi_dump/importer/image/openstack_image_importer.py,sha256=Tc2eZ4fU_2S-fp_vuDWutqPcyV6Erz17nDLjzjusihY,2413
 osi_dump/importer/instance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/importer/instance/instance_importer.py,sha256=TaaPgEFVVMRT3mSXrzQkSaSIBPBwwANpEaWCgRsgImc,196
 osi_dump/importer/instance/openstack_instance_importer.py,sha256=b1OB-8_7DlwvOo7TX5zUG64XXtUufKhgCc3lhgNqxaY,3394
+osi_dump/importer/load_balancer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/importer/load_balancer/load_balancer_importer.py,sha256=fzInBlkscqlbhCATeQYXvufc-WHq2pbofTJJifN0zaY,218
+osi_dump/importer/load_balancer/openstack_load_balancer_importer.py,sha256=Uh94UJLeKCSmDAuPORf-TJbl3nVYzkB4lDxt2J6-d88,2072
 osi_dump/importer/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osi_dump/importer/project/openstack_project_importer.py,sha256=wdNJTTEhsvhnW6Wn0xLx8nAoJOhtiG9-6jGB0WnnYVU,1837
+osi_dump/importer/project/openstack_project_importer.py,sha256=K8Si2uaC88L2CxXi68A4ML9mlWKwnZp1ABDiufFUZ8g,2988
 osi_dump/importer/project/project_importer.py,sha256=jwEvxteFbSwyWMV8hKAtf5Lo2bZysWkQ1L_NVUE8XOQ,191
+osi_dump/importer/role_assignment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osi_dump/importer/role_assignment/openstack_role_assignment_importer.py,sha256=nESax2gka0BpKUA2phmk1-wx0IjFLA1xGf-mORHZgFg,2598
+osi_dump/importer/role_assignment/role_assignment_importer.py,sha256=Faorx0qsgdXjv5y2t-7obpV3wFfbmByx_-8b9yBr7L8,228
 osi_dump/importer/volume/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osi_dump/importer/volume/openstack_volume_importer.py,sha256=dKIOezidH3IZhlp6745XruJbxdzeMzXE-q4x0SYAe74,2007
+osi_dump/importer/volume/openstack_volume_importer.py,sha256=Tte9fX91oxEoRcUZPJd7g6oH6izcWy8WwFCapg_ZY1M,2454
 osi_dump/importer/volume/volume_importer.py,sha256=tmDTE9L9vtl75GR79blSxa_MVsRU6LDCbR0yJk0xKwo,186
 osi_dump/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osi_dump/model/authentication_info.py,sha256=02kXxtILfjh8t45_-bPM8rtyRk2cQcJK6l2d1bPih7k,257
+osi_dump/model/flavor.py,sha256=-G8FaH_qiVrgtRxAWhdpC1c9FRdXLRroG-WJ03-DRZ4,318
 osi_dump/model/floating_ip.py,sha256=CRJufC5ZaxxcbGvdot7Af-sO8uyKbyQK9zHljfBnyFA,427
-osi_dump/model/hypervisor.py,sha256=L3FKY57HiI55-AgxNPXVT55BgkJUDwPFYIfzLprJ2VE,244
+osi_dump/model/hypervisor.py,sha256=pToa-rg7LldKd-h3aNZDJQPy5dhYDIXehq-tr8_xv1I,336
+osi_dump/model/image.py,sha256=ahW0rRb2mgqoPqYhRzn_qnyShKvCvNZPlcDs_bnyt6g,445
 osi_dump/model/instance.py,sha256=flNywojuBj7ZyFTnWvl2rpvzL3Ju-QtuUY69DSPfPs8,464
-osi_dump/model/project.py,sha256=vh3qhR5JpQ6yxvGK9CXiJ9-HoyyYGAggKF56AEEg-tE,289
-osi_dump/model/volume.py,sha256=unb2dy7dIDi3-D6WKJAhmnPsn_DI27GZJsZCrDBh89M,335
+osi_dump/model/load_balancer.py,sha256=ve0vEbIAZLR7RBCbEk_MGR8wrfKQ9dI21Jx6V7nFoR4,298
+osi_dump/model/project.py,sha256=3fNsDcWxuRVBS96W98C_Fia82qt14InjUM7n7rBCX6E,679
+osi_dump/model/role_assignment.py,sha256=dwuXVxgHJ8pIu8_i_w9kZ0r0uaQQXAMDTYnLrDY3O9U,290
+osi_dump/model/volume.py,sha256=1p5Xw0LPxfroJwSYtE-n_Gv4MsRDA_sSvc7SQY_Uo8I,371
 osi_dump/os_connection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osi_dump/os_connection/get_connections.py,sha256=_CiKot2GgQDOAJ33goN9mcwaGYQCqzCOitntz9cf3-c,1793
+osi_dump/os_connection/get_connections.py,sha256=1zeir4cEtzJOUOn53zUmlD9lWMvYXhuRr0IhI5U1DAw,1753
 osi_dump/util/__init__.py,sha256=GvhYTETVePJAsp0LfseMGtuRFWbbCc2xox-QSGQA3Us,286
 osi_dump/util/create_file.py,sha256=hcEspFD0VZDtXCaG5QtMkV37GsbAHATdxYlClTszVK8,242
 osi_dump/util/excel_autosize_column.py,sha256=zzQ6uXkQhHAqVn9fUAgNjoCH_HiNEC9Dcj4OBqHd6rw,1102
@@ -54,8 +89,8 @@ osi_dump/util/excel_sort_sheet.py,sha256=o4jXtP1ZFYtAGzkAP5S8Tym4h-SEoFBAI3j24y-
 osi_dump/util/export_data_excel.py,sha256=VYSxDBZ7dgSbTj3n_8RRPqe183tILNh6wJW-UnFvJUU,882
 osi_dump/util/extract_hostname.py,sha256=IpdklGHevmtRu67xeSRE_5n2mvWGI1sDsnJwExo_AR0,111
 osi_dump/util/validate_dir_path.py,sha256=pL_OrY8JnNwk3vj6Zp6bsZtgHXhszSGRoqIt-1G5S90,507
-osi_dump-0.1.1.dist-info/METADATA,sha256=z48w2kSB9iL1CiVn2E3jP3FzExf4R1P5dIZ_Xu51vxU,662
-osi_dump-0.1.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-osi_dump-0.1.1.dist-info/entry_points.txt,sha256=ozm5sIBtXzLv6_FiUe26v1BgA3_xUReGLPhKQKZ56wQ,46
-osi_dump-0.1.1.dist-info/top_level.txt,sha256=OtAAwmJfcoPvlw_Cemo_H1aXIGV_7w0O2941KQt6faQ,9
-osi_dump-0.1.1.dist-info/RECORD,,
+osi_dump-0.1.2.1.dist-info/METADATA,sha256=DCMaAo3uYHiZeiyqjcWStEokaKxFKuzgYH-_-JIDBnE,664
+osi_dump-0.1.2.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+osi_dump-0.1.2.1.dist-info/entry_points.txt,sha256=ozm5sIBtXzLv6_FiUe26v1BgA3_xUReGLPhKQKZ56wQ,46
+osi_dump-0.1.2.1.dist-info/top_level.txt,sha256=OtAAwmJfcoPvlw_Cemo_H1aXIGV_7w0O2941KQt6faQ,9
+osi_dump-0.1.2.1.dist-info/RECORD,,

{osi_dump-0.1.1.dist-info → osi_dump-0.1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (72.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any