osi-dump 0.1__py3-none-any.whl

osi_dump/importer/floating_ip/openstack_floating_ip_importer.py

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

osi_dump/importer/hypervisor/hypervisor_importer.py

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

osi_dump/importer/hypervisor/openstack_hypervisor_importer.py

@@ -0,0 +1,79 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.compute.v2.hypervisor import Hypervisor as OSHypervisor
+
+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
+
+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_
+        """
+
+        logger.info(f"Importing hypervisors for {self.connection.auth['auth_url']}")
+
+        try:
+            oshypervisors: list[OSHypervisor] = list(self.connection.list_hypervisors())
+        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)
+                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 _get_hypervisor_info(self, hypervisor: OSHypervisor) -> Hypervisor:
+
+        placement_proxy: PlacementProxy = self.connection.placement
+
+        rpi: ResourceProviderInventory = list(
+            placement_proxy.resource_provider_inventories(
+                resource_provider=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"],
+            vpus=vcpu["max_unit"],
+        )
+
+        return ret_hypervisor

osi_dump/importer/instance/instance_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.instance import Instance
+
+
+class InstanceImporter(ABC):
+    @abstractmethod
+    def import_instances(self) -> list[Instance]:
+        pass

osi_dump/importer/instance/openstack_instance_importer.py

@@ -0,0 +1,107 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.compute.v2.server import Server
+
+from osi_dump.importer.instance.instance_importer import InstanceImporter
+from osi_dump.model.instance import Instance
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackInstanceImporter(InstanceImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_instances(self) -> list[Instance]:
+        """Import instances information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching server failed
+
+        Returns:
+            list[Instance]: _description_
+        """
+
+        logger.info(f"Importing instances for {self.connection.auth['auth_url']}")
+
+        try:
+            servers: list[Server] = list(
+                self.connection.compute.servers(details=True, all_projects=True)
+            )
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch instances for {self.connection.auth['auth_url']}"
+            ) from e
+
+        instances: list[Instance] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_instance_info, server) for server in servers
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                instances.append(future.result())
+
+        logger.info(f"Imported instances for {self.connection.auth['auth_url']}")
+
+        return instances
+
+    def _get_instance_info(self, server: Server) -> Instance:
+
+        # Lấy thông tin project
+        try:
+            project = self.connection.identity.get_project(server.project_id)
+            project_name = project.name
+            project_id = project.id
+        except Exception as e:
+            logger.warn(
+                f"Unable to obtain project name for instance: {server.name}: {e}"
+            )
+            project_name = None
+            project_id = None
+
+        # Lấy thông tin domain
+        try:
+            domain = self.connection.identity.get_domain(project.domain_id)
+            domain_name = domain.name
+        except Exception as e:
+            logger.warning(
+                f"Unable to obtain domain name for instance {server.name}: {e}"
+            )
+            domain_name = None
+
+        # Lấy thông tin IPv4 private
+        private_v4_ips = []
+        floating_ip = None
+
+        try:
+            for ips in server.addresses.values():
+                for ip in ips:
+                    if ip["OS-EXT-IPS:type"] == "fixed":
+                        private_v4_ips.append(ip["addr"])
+                    elif ip["OS-EXT-IPS:type"] == "floating":
+                        floating_ip = ip["addr"]
+        except Exception as e:
+            logger.warning(
+                f"Unable to obtain IP address information for instance {server.name}: {e}"
+            )
+
+        instance = Instance(
+            instance_id=server.id,
+            instance_name=server.name,
+            project_id=project_id,
+            project_name=project_name,
+            domain_name=domain_name,
+            private_v4_ips=private_v4_ips,
+            floating_ip=floating_ip,
+            status=server.status,
+            ram=server.flavor["ram"],
+            vcpus=server.flavor["vcpus"],
+            created_at=server.created_at,
+            updated_at=server.updated_at,
+        )
+
+        return instance

osi_dump/importer/project/openstack_project_importer.py

@@ -0,0 +1,60 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.identity.v3.project import Project as OSProject
+
+from osi_dump.importer.project.project_importer import ProjectImporter
+from osi_dump.model.project import Project
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackProjectImporter(ProjectImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_projects(self) -> list[Project]:
+        """Import projects information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching project failed
+
+        Returns:
+            list[Instance]: _description_
+        """
+
+        logger.info(f"Importing projects for {self.connection.auth['auth_url']}")
+
+        try:
+            osprojects: list[OSProject] = list(self.connection.identity.projects())
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch projects for {self.connection.auth['auth_url']}"
+            ) from e
+
+        projects: list[Project] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_project_info, project)
+                for project in osprojects
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                projects.append(future.result())
+
+        logger.info(f"Imported projects for {self.connection.auth['auth_url']}")
+
+        return projects
+
+    def _get_project_info(self, project: OSProject) -> Project:
+        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,
+        )
+
+        return project_ret

osi_dump/importer/project/project_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.project import Project
+
+
+class ProjectImporter(ABC):
+    @abstractmethod
+    def import_projects(self) -> list[Project]:
+        pass

osi_dump/importer/volume/openstack_volume_importer.py

@@ -0,0 +1,64 @@
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+
+from openstack.block_storage.v3.volume import Volume as OSVolume
+
+from osi_dump.importer.volume.volume_importer import VolumeImporter
+from osi_dump.model.volume import Volume
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackVolumeImporter(VolumeImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_volumes(self) -> list[Volume]:
+        """Import hypervisors information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching hypervisor failed
+
+        Returns:
+            list[Hypervisor]: _description_
+        """
+
+        logger.info(f"Importing volumes for {self.connection.auth['auth_url']}")
+
+        try:
+            osvolumes: list[OSVolume] = list(self.connection.list_volumes())
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch volumes for {self.connection.auth['auth_url']}"
+            ) from e
+
+        volumes: list[Volume] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_volume_info, volume) for volume in osvolumes
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                volumes.append(future.result())
+
+        logger.info(f"Imported volumes for {self.connection.auth['auth_url']}")
+
+        return volumes
+
+    def _get_volume_info(self, volume: OSVolume) -> Volume:
+
+        ret_volume = Volume(
+            volume_id=volume.id,
+            project_id=volume.project_id,
+            status=volume.status,
+            attachments=[att["server_id"] for att in volume.attachments],
+            type=volume.volume_type,
+            size=volume.size,
+            updated_at=volume.updated_at,
+            created_at=volume.created_at,
+        )
+
+        return ret_volume

osi_dump/importer/volume/volume_importer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from osi_dump.model.volume import Volume
+
+
+class VolumeImporter(ABC):
+    @abstractmethod
+    def import_volumes(self) -> list[Volume]:
+        pass

osi_dump/model/authentication_info.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class AuthenticationInfo(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    auth_url: str
+    project_name: str
+    username: str
+    password: str
+    user_domain_name: str
+    project_domain_name: str

osi_dump/model/floating_ip.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class FloatingIP(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    floating_ip_id: str
+    project_id: Optional[str]
+
+    floating_network: str
+
+    floating_ip_address: str
+
+    fixed_ip_address: Optional[str]
+
+    router_id: Optional[str]
+
+    port_id: Optional[str]
+
+    status: str
+    created_at: str
+    updated_at: str

osi_dump/model/hypervisor.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Hypervisor(BaseModel):
+    hypervisor_id: str
+    hypervisor_type: str
+    name: str
+    state: str
+    status: str
+    local_disk_size: int
+    memory_size: int
+    vpus: int

osi_dump/model/instance.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Instance(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    instance_id: str
+    instance_name: Optional[str]
+    project_id: Optional[str]
+    project_name: Optional[str]
+    domain_name: Optional[str]
+    private_v4_ips: Optional[list[str]]
+    floating_ip: Optional[str]
+    status: str
+    ram: int
+    vcpus: int
+    created_at: str
+    updated_at: str

osi_dump/model/project.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Project(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    project_id: str
+    project_name: Optional[str]
+    domain_id: Optional[str]
+    enabled: bool
+    parent_id: Optional[str]

osi_dump/model/volume.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Volume(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    volume_id: str
+
+    project_id: Optional[str]
+
+    attachments: Optional[list[str]]
+
+    status: str
+
+    type: str
+    size: int
+
+    updated_at: str
+    created_at: str

osi_dump/os_connection/get_connections.py

@@ -0,0 +1,67 @@
+import json
+import logging
+
+from pydantic import ValidationError
+
+import typer
+
+import openstack
+from openstack.connection import Connection
+
+from osi_dump.model.authentication_info import AuthenticationInfo
+
+
+logger = logging.getLogger(__name__)
+
+TIMEOUT_SECOND = 30
+
+
+def get_connections(file_path) -> list[Connection]:
+    auths = _parse_authentication_info(file_path=file_path)
+
+    logger.info("Getting connections")
+
+    connections = []
+    auth_urls = []
+
+    for auth in auths:
+        try:
+            connection = openstack.connect(
+                auth_url=auth.auth_url,
+                project_name=auth.project_name,
+                username=auth.username,
+                password=auth.password,
+                project_domain_name=auth.project_domain_name,
+                user_domain_name=auth.user_domain_name,
+                timeout=TIMEOUT_SECOND,
+            )
+
+            connections.append(connection)
+            auth_urls.append(auth.auth_url)
+        except Exception as e:
+            logger.warning(f"Skipping {auth.auth_url}... error: {e}")
+            pass
+
+    logger.info("Established connection success with: ")
+    for auth_url in auth_urls:
+        logger.info(f"{auth_url}")
+
+    return connections
+
+
+def _parse_authentication_info(file_path: str) -> list[AuthenticationInfo]:
+
+    with open(file_path, "r") as file:
+        objects = json.load(file)
+        if not isinstance(objects, list) or len(objects) == 0:
+            raise ValueError(
+                "The JSON file must contain a list with at least one object."
+            )
+
+        try:
+            ret = [AuthenticationInfo.model_validate(obj) for obj in objects]
+        except ValidationError as e:
+            logger.error(e.errors())
+            raise typer.Exit(1)
+
+        return ret

osi_dump/util/__init__.py

@@ -0,0 +1,6 @@
+from .excel_autosize_column import excel_autosize_column
+from .extract_hostname import extract_hostname
+from .create_file import create_file
+from .export_data_excel import export_data_excel
+from .excel_sort_sheet import excel_sort_sheet
+from .validate_dir_path import validate_dir_path

osi_dump/util/create_file.py

@@ -0,0 +1,11 @@
+import os
+
+
+def create_file(file_path: str):
+    # Check if the file already exists
+    if os.path.exists(file_path):
+        # Delete the old file
+        os.remove(file_path)
+
+    # Create and write to the new file
+    open(file_path, "x")

osi_dump/util/excel_autosize_column.py

@@ -0,0 +1,39 @@
+from openpyxl import load_workbook
+
+
+def excel_autosize_column(file_path: str):
+    """Auto size column for all sheets in excel file
+
+    Args:
+        file_path (str): Path to excel file
+
+    Raises:
+        e: Exception when loading workbook
+    """
+    try:
+        wb = load_workbook(file_path)
+    except Exception as e:
+        raise e
+
+    # Iterate through all sheets
+    for sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+
+        # Auto-size columns
+        for col in ws.columns:
+            max_length = 0
+            column = col[0].column_letter  # Get the column name (e.g., 'A')
+            for cell in col:
+                try:
+                    if cell.value:
+                        cell_length = len(str(cell.value))
+                        if cell_length > max_length:
+                            max_length = cell_length
+                except:
+                    pass
+            adjusted_width = max_length + 2  # Adjust as needed for padding
+            ws.column_dimensions[column].width = adjusted_width
+
+    # Save the modified workbook
+
+    wb.save(file_path)