osi-dump 0.1__py3-none-any.whl

osi_dump/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from osi_dump.cli import app
+
+    app()

osi_dump/batch_handler/__init__.py

@@ -0,0 +1,5 @@
+from .instance_batch_handler import InstanceBatchHandler
+from .project_batch_handler import ProjectBatchHandler
+from .hypervisor_batch_handler import HypervisorBatchHandler
+from .floating_ip_batch_handler import FloatingIPBatchHandler
+from .volume_batch_handler import VolumeBatchHandler

osi_dump/batch_handler/floating_ip_batch_handler.py

@@ -0,0 +1,57 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.floating_ip.floating_ip_exporter import FloatingIPExporter
+from osi_dump.exporter.floating_ip.excel_floating_ip_exporter import (
+    ExcelFloatingIPExporter,
+)
+
+from osi_dump.importer.floating_ip.floating_ip_importer import FloatingIPImporter
+from osi_dump.importer.floating_ip.openstack_floating_ip_importer import (
+    OpenStackFloatingIPImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class FloatingIPBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[
+            tuple[FloatingIPImporter, FloatingIPExporter]
+        ] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackFloatingIPImporter(connection)
+
+            sheet_name = (
+                f"{util.extract_hostname(connection.auth['auth_url'])}-floating-ip"
+            )
+            exporter = ExcelFloatingIPExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(
+        self, importer: FloatingIPImporter, exporter: FloatingIPExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+
+        for importer, exporter in self._importer_exporter_list:
+            try:
+
+                floating_ips = importer.import_floating_ips()
+
+                exporter.export_floating_ips(floating_ips=floating_ips)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/hypervisor_batch_handler.py

@@ -0,0 +1,55 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.hypervisor.hypervisor_exporter import HypervisorExporter
+from osi_dump.exporter.hypervisor.excel_hypervisor_exporter import (
+    ExcelHypervisorExporter,
+)
+
+from osi_dump.importer.hypervisor.hypervisor_importer import HypervisorImporter
+from osi_dump.importer.hypervisor.openstack_hypervisor_importer import (
+    OpenStackHypervisorImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class HypervisorBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[
+            tuple[HypervisorImporter, HypervisorExporter]
+        ] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackHypervisorImporter(connection)
+
+            sheet_name = (
+                f"{util.extract_hostname(connection.auth['auth_url'])}-hypervisor"
+            )
+            exporter = ExcelHypervisorExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(
+        self, importer: HypervisorImporter, exporter: HypervisorExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+        for importer, exporter in self._importer_exporter_list:
+            try:
+                hypervisors = importer.import_hypervisors()
+
+                exporter.export_hypervisors(hypervisors=hypervisors)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/instance_batch_handler.py

@@ -0,0 +1,54 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.instance.excel_instance_exporter import ExcelInstanceExporter
+from osi_dump.exporter.instance.instance_exporter import InstanceExporter
+from osi_dump.importer.instance.instance_importer import InstanceImporter
+from osi_dump.importer.instance.openstack_instance_importer import (
+    OpenStackInstanceImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class InstanceBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[
+            tuple[InstanceImporter, InstanceExporter]
+        ] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            instance_importer = OpenStackInstanceImporter(connection)
+
+            sheet_name = (
+                f"{util.extract_hostname(connection.auth['auth_url'])}-instance"
+            )
+            instance_exporter = ExcelInstanceExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(
+                importer=instance_importer, exporter=instance_exporter
+            )
+
+    def add_importer_exporter(
+        self, importer: InstanceImporter, exporter: InstanceExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+        for importer, exporter in self._importer_exporter_list:
+            try:
+                instances = importer.import_instances()
+
+                exporter.export_instances(instances=instances)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/project_batch_handler.py

@@ -0,0 +1,51 @@
+import logging
+
+from openstack.connection import Connection
+
+from osi_dump.exporter.project.project_exporter import (
+    ProjectExporter,
+)
+from osi_dump.exporter.project.excel_project_exporter import ExcelProjectExporter
+
+from osi_dump.importer.project.project_importer import ProjectImporter
+from osi_dump.importer.project.openstack_project_importer import (
+    OpenStackProjectImporter,
+)
+
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[tuple[ProjectImporter, ProjectExporter]] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackProjectImporter(connection)
+
+            sheet_name = f"{util.extract_hostname(connection.auth['auth_url'])}-project"
+            exporter = ExcelProjectExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(
+        self, importer: ProjectImporter, exporter: ProjectExporter
+    ):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+        for importer, exporter in self._importer_exporter_list:
+            try:
+                projects = importer.import_projects()
+
+                exporter.export_projects(projects=projects)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/batch_handler/volume_batch_handler.py

@@ -0,0 +1,45 @@
+import logging
+
+from openstack.connection import Connection
+
+
+from osi_dump.exporter.volume.excel_volume_exporter import ExcelVolumeExporter
+from osi_dump.exporter.volume.volume_exporter import VolumeExporter
+
+
+from osi_dump import util
+from osi_dump.importer.volume.openstack_volume_importer import OpenStackVolumeImporter
+from osi_dump.importer.volume.volume_importer import VolumeImporter
+
+logger = logging.getLogger(__name__)
+
+
+class VolumeBatchHandler:
+    def __init__(self):
+        self._importer_exporter_list: list[tuple[VolumeImporter, VolumeExporter]] = []
+
+    def add_importer_exporter_from_openstack_connections(
+        self, connections: list[Connection], output_file: str
+    ):
+        for connection in connections:
+            importer = OpenStackVolumeImporter(connection)
+
+            sheet_name = f"{util.extract_hostname(connection.auth['auth_url'])}-volume"
+            exporter = ExcelVolumeExporter(
+                sheet_name=sheet_name, output_file=output_file
+            )
+
+            self.add_importer_exporter(importer=importer, exporter=exporter)
+
+    def add_importer_exporter(self, importer: VolumeImporter, exporter: VolumeExporter):
+        self._importer_exporter_list.append((importer, exporter))
+
+    def process(self):
+        for importer, exporter in self._importer_exporter_list:
+            try:
+                volumes = importer.import_volumes()
+
+                exporter.export_volumes(volumes=volumes)
+            except Exception as e:
+                logger.warning(e)
+                logger.warning("Skipping...")

osi_dump/cli.py

@@ -0,0 +1,156 @@
+import logging
+
+import os
+
+from pathlib import Path
+
+import typer
+
+from typing_extensions import Annotated
+
+app = typer.Typer()
+
+
+from osi_dump.batch_handler.volume_batch_handler import VolumeBatchHandler
+from osi_dump.os_connection.get_connections import get_connections
+
+
+from osi_dump.batch_handler import (
+    InstanceBatchHandler,
+    ProjectBatchHandler,
+    HypervisorBatchHandler,
+    FloatingIPBatchHandler,
+)
+
+
+from osi_dump import util
+
+
+def _instance(connections, output_path: str):
+    instance_batch_handler = InstanceBatchHandler()
+
+    instance_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    instance_batch_handler.process()
+
+
+def _floating_ip(connections, output_path: str):
+    floating_ip_batch_handler = FloatingIPBatchHandler()
+
+    floating_ip_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    floating_ip_batch_handler.process()
+
+
+def _volume(connections, output_path: str):
+    volume_batch_handler = VolumeBatchHandler()
+
+    volume_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    volume_batch_handler.process()
+
+
+def _project(connections, output_path: str):
+    project_batch_handler = ProjectBatchHandler()
+
+    project_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    project_batch_handler.process()
+
+
+def _hypervisor(connections, output_path: str):
+    hypervisor_batch_handler = HypervisorBatchHandler()
+
+    hypervisor_batch_handler.add_importer_exporter_from_openstack_connections(
+        connections, output_file=output_path
+    )
+
+    hypervisor_batch_handler.process()
+
+
+def inner_main(file_path: str, output_path: str):
+
+    logger = logging.getLogger(__name__)
+
+    connections = get_connections(file_path=file_path)
+
+    _instance(connections=connections, output_path=output_path)
+
+    _floating_ip(connections=connections, output_path=output_path)
+
+    _volume(connections=connections, output_path=output_path)
+
+    _hypervisor(connections=connections, output_path=output_path)
+
+    _project(connections=connections, output_path=output_path)
+
+    util.excel_autosize_column(output_path)
+
+    util.excel_sort_sheet(output_path)
+
+    logger.info(
+        f"Exported OpenStack information to file: {os.path.abspath(output_path)}"
+    )
+
+
+def main(
+    file_path: Annotated[
+        Path,
+        typer.Argument(
+            help=(
+                """
+            Path of the file containing OpenStack authentication information.
+
+            The expected JSON file format is as follows:
+
+\b
+[
+    {
+	"auth_url": "string",
+	"project_name": "string",
+	"username": "string",
+	"password": "string",
+	"user_domain_name": "string",
+	"project_domain_name": "string"
+    }
+]
+            """
+            )
+        ),
+    ],
+    output_path: Annotated[
+        Path,
+        typer.Argument(
+            help="""
+\b
+Path of the output file, will override if file already exists
+             
+                """
+        ),
+    ] = "output.xlsx",
+):
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+
+    logger = logging.getLogger(__name__)
+
+    if util.validate_dir_path(file_path=output_path) is False:
+        logger.error(f"Invalid path: {output_path}, folder does not exist.")
+        raise typer.Exit(1)
+
+    inner_main(file_path=file_path, output_path=output_path)
+
+
+app.command()(main)
+
+if __name__ == "__main__":
+    app()

osi_dump/exporter/floating_ip/excel_floating_ip_exporter.py

@@ -0,0 +1,30 @@
+import logging
+
+from openpyxl import load_workbook
+import pandas as pd
+
+
+from osi_dump.exporter.floating_ip.floating_ip_exporter import FloatingIPExporter
+
+from osi_dump.model.floating_ip import FloatingIP
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelFloatingIPExporter(FloatingIPExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_floating_ips(self, floating_ips: list[FloatingIP]):
+        df = pd.DataFrame([floating_ip.model_dump() for floating_ip in floating_ips])
+
+        logger.info(f"Exporting floating ips for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported floating ips for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting floating ips for {self.sheet_name} error: {e}")

osi_dump/exporter/floating_ip/floating_ip_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class FloatingIPExporter(ABC):
+    @abstractmethod
+    def export_floating_ips(self, floating_ips, output_file: str):
+        pass

osi_dump/exporter/hypervisor/excel_hypervisor_exporter.py

@@ -0,0 +1,30 @@
+import logging
+
+from openpyxl import load_workbook
+import pandas as pd
+
+
+from osi_dump.exporter.hypervisor.hypervisor_exporter import HypervisorExporter
+
+from osi_dump.model.hypervisor import Hypervisor
+
+from osi_dump import util
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelHypervisorExporter(HypervisorExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_hypervisors(self, hypervisors: list[Hypervisor]):
+        df = pd.DataFrame([hypervisor.model_dump() for hypervisor in hypervisors])
+
+        logger.info(f"Exporting hypervisors for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported hypervisors for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting hypervisors for {self.sheet_name} error: {e}")

osi_dump/exporter/hypervisor/hypervisor_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class HypervisorExporter(ABC):
+    @abstractmethod
+    def export_hypervisors(self, hypervisors, output_file: str):
+        pass

osi_dump/exporter/instance/excel_instance_exporter.py

@@ -0,0 +1,29 @@
+import pandas as pd
+
+import logging
+
+from openpyxl import load_workbook
+
+from osi_dump import util
+from osi_dump.exporter.instance.instance_exporter import InstanceExporter
+
+from osi_dump.model.instance import Instance
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelInstanceExporter(InstanceExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_instances(self, instances: list[Instance]):
+        df = pd.DataFrame([instance.model_dump() for instance in instances])
+
+        logger.info(f"Exporting instances for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported instances for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting instances for {self.sheet_name} error: {e}")

osi_dump/exporter/instance/instance_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class InstanceExporter(ABC):
+    @abstractmethod
+    def export_instances(self, instances, output_file: str):
+        pass

osi_dump/exporter/project/excel_project_exporter.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+import logging
+
+from openpyxl import load_workbook
+
+from osi_dump import util
+from osi_dump.exporter.project.project_exporter import ProjectExporter
+
+from osi_dump.model.project import Project
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelProjectExporter(ProjectExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_projects(self, projects: list[Project]):
+
+        df = pd.DataFrame([project.model_dump() for project in projects])
+
+        logger.info(f"Exporting projects for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported projects for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting projects for {self.sheet_name} error: {e}")

osi_dump/exporter/project/project_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class ProjectExporter(ABC):
+    @abstractmethod
+    def export_projects(self, projects, output_file: str):
+        pass

osi_dump/exporter/volume/excel_volume_exporter.py

@@ -0,0 +1,29 @@
+import pandas as pd
+
+import logging
+
+
+from osi_dump import util
+
+from osi_dump.exporter.volume.volume_exporter import VolumeExporter
+
+from osi_dump.model.volume import Volume
+
+logger = logging.getLogger(__name__)
+
+
+class ExcelVolumeExporter(VolumeExporter):
+    def __init__(self, sheet_name: str, output_file: str):
+        self.sheet_name = sheet_name
+        self.output_file = output_file
+
+    def export_volumes(self, volumes: list[Volume]):
+        df = pd.DataFrame([volume.model_dump() for volume in volumes])
+
+        logger.info(f"Exporting volumes for {self.sheet_name}")
+        try:
+            util.export_data_excel(self.output_file, sheet_name=self.sheet_name, df=df)
+
+            logger.info(f"Exported volumes for {self.sheet_name}")
+        except Exception as e:
+            logger.warning(f"Exporting volumes for {self.sheet_name} error: {e}")

osi_dump/exporter/volume/volume_exporter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class VolumeExporter(ABC):
+    @abstractmethod
+    def export_volumes(self, volumes, output_file: str):
+        pass

osi_dump/importer/floating_ip/floating_ip_importer.py

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