147 lines
4.0 KiB
Python
147 lines
4.0 KiB
Python
from enum import Enum
|
|
import typing
|
|
import strawberry
|
|
from selfprivacy_api.graphql.common_types.dns import DnsRecord
|
|
|
|
from selfprivacy_api.services import get_service_by_id, get_services_by_location
|
|
from selfprivacy_api.services import Service as ServiceInterface
|
|
from selfprivacy_api.utils.block_devices import BlockDevices
|
|
|
|
|
|
def get_usages(root: "StorageVolume") -> list["StorageUsageInterface"]:
|
|
"""Get usages of a volume"""
|
|
return [
|
|
ServiceStorageUsage(
|
|
service=service_to_graphql_service(service),
|
|
title=service.get_display_name(),
|
|
used_space=str(service.get_storage_usage()),
|
|
volume=get_volume_by_id(service.get_location()),
|
|
)
|
|
for service in get_services_by_location(root.name)
|
|
]
|
|
|
|
|
|
@strawberry.type
|
|
class StorageVolume:
|
|
"""Stats and basic info about a volume or a system disk."""
|
|
|
|
total_space: str
|
|
free_space: str
|
|
used_space: str
|
|
root: bool
|
|
name: str
|
|
model: typing.Optional[str]
|
|
serial: typing.Optional[str]
|
|
type: str
|
|
|
|
@strawberry.field
|
|
def usages(self) -> list["StorageUsageInterface"]:
|
|
"""Get usages of a volume"""
|
|
return get_usages(self)
|
|
|
|
|
|
@strawberry.interface
|
|
class StorageUsageInterface:
|
|
used_space: str
|
|
volume: typing.Optional[StorageVolume]
|
|
title: str
|
|
|
|
|
|
@strawberry.type
|
|
class ServiceStorageUsage(StorageUsageInterface):
|
|
"""Storage usage for a service"""
|
|
|
|
service: typing.Optional["Service"]
|
|
|
|
|
|
@strawberry.enum
|
|
class ServiceStatusEnum(Enum):
|
|
ACTIVE = "ACTIVE"
|
|
RELOADING = "RELOADING"
|
|
INACTIVE = "INACTIVE"
|
|
FAILED = "FAILED"
|
|
ACTIVATING = "ACTIVATING"
|
|
DEACTIVATING = "DEACTIVATING"
|
|
OFF = "OFF"
|
|
|
|
|
|
def get_storage_usage(root: "Service") -> ServiceStorageUsage:
|
|
"""Get storage usage for a service"""
|
|
service = get_service_by_id(root.id)
|
|
if service is None:
|
|
return ServiceStorageUsage(
|
|
service=service,
|
|
title="Not found",
|
|
used_space="0",
|
|
volume=get_volume_by_id("sda1"),
|
|
)
|
|
return ServiceStorageUsage(
|
|
service=service_to_graphql_service(service),
|
|
title=service.get_display_name(),
|
|
used_space=str(service.get_storage_usage()),
|
|
volume=get_volume_by_id(service.get_location()),
|
|
)
|
|
|
|
|
|
@strawberry.type
|
|
class Service:
|
|
id: str
|
|
display_name: str
|
|
description: str
|
|
svg_icon: str
|
|
is_movable: bool
|
|
is_required: bool
|
|
is_enabled: bool
|
|
status: ServiceStatusEnum
|
|
url: typing.Optional[str]
|
|
dns_records: typing.Optional[typing.List[DnsRecord]]
|
|
|
|
@strawberry.field
|
|
def storage_usage(self) -> ServiceStorageUsage:
|
|
"""Get storage usage for a service"""
|
|
return get_storage_usage(self)
|
|
|
|
|
|
def service_to_graphql_service(service: ServiceInterface) -> Service:
|
|
"""Convert service to graphql service"""
|
|
return Service(
|
|
id=service.get_id(),
|
|
display_name=service.get_display_name(),
|
|
description=service.get_description(),
|
|
svg_icon=service.get_svg_icon(),
|
|
is_movable=service.is_movable(),
|
|
is_required=service.is_required(),
|
|
is_enabled=service.is_enabled(),
|
|
status=ServiceStatusEnum(service.get_status().value),
|
|
url=service.get_url(),
|
|
dns_records=[
|
|
DnsRecord(
|
|
record_type=record.type,
|
|
name=record.name,
|
|
content=record.content,
|
|
ttl=record.ttl,
|
|
priority=record.priority,
|
|
)
|
|
for record in service.get_dns_records()
|
|
],
|
|
)
|
|
|
|
|
|
def get_volume_by_id(volume_id: str) -> typing.Optional[StorageVolume]:
|
|
"""Get volume by id"""
|
|
volume = BlockDevices().get_block_device(volume_id)
|
|
if volume is None:
|
|
return None
|
|
return StorageVolume(
|
|
total_space=str(volume.fssize)
|
|
if volume.fssize is not None
|
|
else str(volume.size),
|
|
free_space=str(volume.fsavail),
|
|
used_space=str(volume.fsused),
|
|
root=volume.name == "sda1",
|
|
name=volume.name,
|
|
model=volume.model,
|
|
serial=volume.serial,
|
|
type=volume.type,
|
|
)
|