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

osi_dump/importer/router/openstack_router_importer.py

@@ -1,87 +1,87 @@
-import logging
-
-import concurrent
-
-from openstack.connection import Connection
-from openstack.network.v2.router import Router as OSRouter
-
-from osi_dump.importer.router.router_importer import (
-    RouterImporter,
-)
-from osi_dump.model.router import Router
-
-logger = logging.getLogger(__name__)
-
-
-class OpenStackRouterImporter(RouterImporter):
-    def __init__(self, connection: Connection):
-        self.connection = connection
-
-    def import_routers(self) -> list[Router]:
-        """Import routers information from Openstack
-
-        Raises:
-            Exception: Raises exception if fetching router failed
-
-        Returns:
-            list[Router]: _description_
-        """
-
-        logger.info(f"Importing routers for {self.connection.auth['auth_url']}")
-
-        try:
-            osrouters: list[OSRouter] = list(self.connection.network.routers())
-        except Exception as e:
-            raise Exception(
-                f"Can not fetch routers for {self.connection.auth['auth_url']}"
-            ) from e
-
-        routers: list[Router] = []
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(self._get_router_info, router) for router in osrouters
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                routers.append(future.result())
-
-        logger.info(f"Imported routers for {self.connection.auth['auth_url']}")
-
-        return routers
-
-    def _get_router_info(self, router: OSRouter) -> Router:
-        """
-                {"network_id": "49760654-71d8-4967-8fdd-5a35d3ff78ef", "external_fixed_ips": [{"subnet_id":                                   |
-        |                           | "c044a5c0-4b11-4d8d-ae5e-9ff4ce6c1be6", "ip_address": "10.0.2.188"}], "enable_snat": true}
-        """
-
-        external_net_id = None
-
-        try:
-            external_net_id = router.external_gateway_info["network_id"]
-        except Exception as e:
-            logger.warning(f"Could not get external net id for router: {router.id}")
-
-        external_net_ip = None
-
-        try:
-            external_net_ip = router.external_gateway_info["external_fixed_ips"][0][
-                "ip_address"
-            ]
-
-        except Exception as e:
-            logger.warning(f"Could not get external net ip for router {router.id}")
-
-        router_ret = Router(
-            router_id=router.id,
-            name=router.name,
-            external_net_id=external_net_id,
-            external_net_ip=external_net_ip,
-            status=router.status,
-            admin_state=router.is_admin_state_up,
-            project_id=router.project_id,
-            created_at=router.created_at,
-            updated_at=router.updated_at,
-        )
-
-        return router_ret
+import logging
+
+import concurrent
+
+from openstack.connection import Connection
+from openstack.network.v2.router import Router as OSRouter
+
+from osi_dump.importer.router.router_importer import (
+    RouterImporter,
+)
+from osi_dump.model.router import Router
+
+logger = logging.getLogger(__name__)
+
+
+class OpenStackRouterImporter(RouterImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_routers(self) -> list[Router]:
+        """Import routers information from Openstack
+
+        Raises:
+            Exception: Raises exception if fetching router failed
+
+        Returns:
+            list[Router]: _description_
+        """
+
+        logger.info(f"Importing routers for {self.connection.auth['auth_url']}")
+
+        try:
+            osrouters: list[OSRouter] = list(self.connection.network.routers())
+        except Exception as e:
+            raise Exception(
+                f"Can not fetch routers for {self.connection.auth['auth_url']}"
+            ) from e
+
+        routers: list[Router] = []
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self._get_router_info, router) for router in osrouters
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                routers.append(future.result())
+
+        logger.info(f"Imported routers for {self.connection.auth['auth_url']}")
+
+        return routers
+
+    def _get_router_info(self, router: OSRouter) -> Router:
+        """
+                {"network_id": "49760654-71d8-4967-8fdd-5a35d3ff78ef", "external_fixed_ips": [{"subnet_id":                                   |
+        |                           | "c044a5c0-4b11-4d8d-ae5e-9ff4ce6c1be6", "ip_address": "10.0.2.188"}], "enable_snat": true}
+        """
+
+        external_net_id = None
+
+        try:
+            external_net_id = router.external_gateway_info["network_id"]
+        except Exception as e:
+            logger.warning(f"Could not get external net id for router: {router.id}")
+
+        external_net_ip = None
+
+        try:
+            external_net_ip = router.external_gateway_info["external_fixed_ips"][0][
+                "ip_address"
+            ]
+
+        except Exception as e:
+            logger.warning(f"Could not get external net ip for router {router.id}")
+
+        router_ret = Router(
+            router_id=router.id,
+            name=router.name,
+            external_net_id=external_net_id,
+            external_net_ip=external_net_ip,
+            status=router.status,
+            admin_state=router.is_admin_state_up,
+            project_id=router.project_id,
+            created_at=router.created_at,
+            updated_at=router.updated_at,
+        )
+
+        return router_ret

osi_dump/importer/router/router_importer.py

@@ -1,9 +1,9 @@
-from abc import ABC, abstractmethod
-
-from osi_dump.model.router import Router
-
-
-class RouterImporter(ABC):
-    @abstractmethod
-    def import_routers(self) -> list[Router]:
-        pass
+from abc import ABC, abstractmethod
+
+from osi_dump.model.router import Router
+
+
+class RouterImporter(ABC):
+    @abstractmethod
+    def import_routers(self) -> list[Router]:
+        pass

osi_dump/importer/security_group/openstack_security_group_importer.py

@@ -0,0 +1,54 @@
+import logging
+from typing import Generator
+from openstack.connection import Connection
+from openstack.network.v2.security_group import SecurityGroup as OSSecurityGroup
+
+from osi_dump.importer.security_group.security_group_importer import SecurityGroupImporter
+from osi_dump.model.security_group import SecurityGroup, SecurityGroupRule
+
+logger = logging.getLogger(__name__)
+
+class OpenStackSecurityGroupImporter(SecurityGroupImporter):
+    def __init__(self, connection: Connection):
+        self.connection = connection
+
+    def import_security_groups(self) -> Generator[SecurityGroup, None, None]:
+        logger.info(f"Importing security groups for {self.connection.auth['auth_url']}")
+        try:
+            os_sec_groups_iterator = self.connection.network.security_groups()
+
+            for os_sec_group in os_sec_groups_iterator:
+                yield self._get_sec_group_info(os_sec_group)
+
+        except Exception as e:
+            logger.error(f"Cannot fetch security groups for {self.connection.auth['auth_url']}: {e}")
+            return 
+
+        logger.info(f"Finished importing security groups for {self.connection.auth['auth_url']}")
+
+
+    def _get_sec_group_info(self, os_sec_group: OSSecurityGroup) -> SecurityGroup:
+        rules = []
+        if hasattr(os_sec_group, 'security_group_rules'):
+            for rule in os_sec_group.security_group_rules:
+                port_range = None
+                if rule.get('port_range_min') is not None and rule.get('port_range_max') is not None:
+                    port_range = f"{rule['port_range_min']}-{rule['port_range_max']}"
+
+                rules.append(SecurityGroupRule(
+                    rule_id=rule['id'],
+                    direction=rule['direction'],
+                    protocol=rule.get('protocol'),
+                    ethertype=rule['ethertype'],
+                    port_range=port_range,
+                    remote_ip_prefix=rule.get('remote_ip_prefix'),
+                    remote_group_id=rule.get('remote_group_id')
+                ))
+        
+        return SecurityGroup(
+            security_group_id=os_sec_group.id,
+            name=os_sec_group.name,
+            project_id=os_sec_group.project_id,
+            description=os_sec_group.description,
+            rules=rules
+        )

osi_dump/importer/security_group/security_group_importer.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Generator
+from osi_dump.model.security_group import SecurityGroup
+
+class SecurityGroupImporter(ABC):
+    @abstractmethod
+    def import_security_groups(self) -> Generator[SecurityGroup, None, None]: 
+        pass

osi_dump/importer/volume/openstack_volume_importer.py

@@ -1,81 +1,81 @@
-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.block_storage.volumes(details=True, all_projects=True)
-            )
-        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:
-
-        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,
-            volume_name=volume.name,
-            project_id=volume.project_id,
-            status=volume.status,
-            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,
-        )
-
-        return ret_volume
+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.block_storage.volumes(details=True, all_projects=True)
+            )
+        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:
+
+        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,
+            volume_name=volume.name,
+            project_id=volume.project_id,
+            status=volume.status,
+            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,
+        )
+
+        return ret_volume

osi_dump/importer/volume/volume_importer.py

@@ -1,9 +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
+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

@@ -1,15 +1,15 @@
-from typing import Optional
-
-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
-    interface: Optional[str] = "public"
+from typing import Optional
+
+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
+    interface: Optional[str] = "public"

osi_dump/model/external_port.py

@@ -1,30 +1,30 @@
-from typing import Optional
-
-from pydantic import BaseModel, ConfigDict, ValidationError
-
-
-class ExternalPort(BaseModel):
-    model_config = ConfigDict(strict=True)
-
-    port_id: str
-
-    project_id: Optional[str]
-
-    subnet_id: Optional[str]
-
-    subnet_cidr: Optional[str]
-
-    ip_address: Optional[str]
-
-    network_name: Optional[str]
-    network_id: Optional[str]
-
-    allowed_address_pairs: Optional[list[dict]]
-
-    device_id: Optional[str]
-
-    device_owner: Optional[str]
-
-    status: Optional[str]
-    
-    vlan_id: Optional[int]
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class ExternalPort(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    port_id: str
+
+    project_id: Optional[str]
+
+    subnet_id: Optional[str]
+
+    subnet_cidr: Optional[str]
+
+    ip_address: Optional[str]
+
+    network_name: Optional[str]
+    network_id: Optional[str]
+
+    allowed_address_pairs: Optional[list[dict]]
+
+    device_id: Optional[str]
+
+    device_owner: Optional[str]
+
+    status: Optional[str]
+    
+    vlan_id: Optional[int]

osi_dump/model/flavor.py

@@ -1,20 +1,20 @@
-from typing import Optional
-
-from pydantic import BaseModel, ConfigDict
-
-
-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
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+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/floating_ip.py

@@ -1,24 +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
+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

@@ -1,24 +1,24 @@
-from typing import Optional
-from pydantic import BaseModel, ConfigDict, ValidationError
-
-
-class Hypervisor(BaseModel):
-    hypervisor_id: str
-    hypervisor_type: str
-    name: str
-    state: str
-    status: str
-
-    vcpus: int
-    vcpus_usage: int
-
-    memory_size: int
-    memory_usage: int
-
-    local_disk_usage: int
-    local_disk_size: int
-
-    aggregates: Optional[list[dict]]  # id, name, az
-    availability_zone: Optional[str]
-
-    vm_count: int
+from typing import Optional
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class Hypervisor(BaseModel):
+    hypervisor_id: str
+    hypervisor_type: str
+    name: str
+    state: str
+    status: str
+
+    vcpus: int
+    vcpus_usage: int
+
+    memory_size: int
+    memory_usage: int
+
+    local_disk_usage: int
+    local_disk_size: int
+
+    aggregates: Optional[list[dict]]  # id, name, az
+    availability_zone: Optional[str]
+
+    vm_count: int