deevirt_schema/api/vm.py

from typing import List, Tuple, Optional
from enum import Enum, IntEnum
from uuid import UUID, uuid4
from pydantic_xml import element, attr, wrapped
from pydantic import UUID4, Field, field_serializer, ConfigDict, ValidationInfo, field_validator
from pydantic import BaseModel as _BaseModel
from pydantic_core import core_schema as cs


from pydantic_core import core_schema
from pydantic.json_schema import GetJsonSchemaHandler, JsonSchemaValue

#from deevirt_common.lib.virt import vm as domain
#from deevirt_common.schemas import datacenter_schema, storage_schema, network_schema, configDom

from deevirt_schema.libvirt.dom import config as configDom

class BaseModel(_BaseModel):
    class Config:
        @staticmethod
        def json_schema_extra(schema: dict, _):
            props = {}
            for k, v in schema.get('properties', {}).items():
                if not v.get("hidden", False):
                    props[k] = v
            schema["properties"] = props


""" Common """
class Resource(BaseModel):
    """Experimental"""
    name:Optional[str] = Field(default=None, description="Nom du pool")

class VCPU(BaseModel):
    value:int = Field(description="Nombre de VCPU")
    dedicated:Optional[bool] = Field(default=False, description="VCPU dédié")
    hotplug:Optional[bool] = Field(default=False, description="Ajout de VCPU à chaud.")

class Memory(BaseModel):
    unit:Optional[configDom.UnitEnum] = Field(default=configDom.UnitEnum.GiB, description="Unité de mesure.")
    value:int = Field(description="Taille de la mémoire.")
    hotplug:Optional[bool] = Field(default=False,description="Ajout à chaud de la mémoire.")

class OSBootMenu(BaseModel):
    enable:Optional[bool] = Field(default=False,description="Activation du menu de démarrage.")
    delay:Optional[int] = Field(default=0, description="Delai maximal pour entrer dans le menu démarrage en millisecondes")

class OSBootOrder(BaseModel):
    dev:Optional[configDom.OSBoot.bootEnum] = Field(default=None, description="Périphérique.")

class OSInfo(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    name:str = Field(alias="os.name", serialization_alias="name")
    version:str  = Field(alias="os.version-id", serialization_alias="version")
    machine:str  = Field(alias="os.machine", serialization_alias="architecture")
    kernel:str  = Field(alias="os.kernel-release", serialization_alias="kernel")

class OS(BaseModel):
    firmware:configDom.OS.firmwareEnum = Field(default=configDom.OS.firmwareEnum.bios, description="Microprogramme")
    enrolled_keys:Optional[bool] = Field(default=None, description="Vérification de la signature du chargeur de démarrage")
    secure_boot:Optional[bool] = Field(default=None, description="Démarrage sécurisé")
    boot_order:Optional[List[configDom.OSBoot.bootEnum]] = Field(default=None, description="Ordre de démarrage des périphériques")
    boot_menu:OSBootMenu = Field(default=OSBootMenu(), description="Menu de démarrage")

class Clock(BaseModel):    
    offset:configDom.Clock.offsetEnum = Field(default=configDom.Clock.offsetEnum.utc, description="Sélection de l'offset ?")

class Event(BaseModel):
    class on_poweroffEnum(str, Enum):
        destroy = "destroy"
        restart = "restart"
        preserve = "preverse"

    class on_rebootEnum(str, Enum):
        restart = "restart"
        preserve = "preverse"

    class on_crashEnum(str, Enum):
        destroy = "destroy"
        restart = "restart"
        preserve = "preverse"

    class on_failurelockEnum(str, Enum):
        poweroff = "poweroff"
        restart = "restart"
        pause = "pause"
        ignore = "ignore"

    on_poweroff:configDom.Dom.on_poweroffEnum = Field(default=configDom.Dom.on_poweroffEnum.destroy, description="Action lors d'un poweroff")
    on_reboot:configDom.Dom.on_rebootEnum = Field(default=configDom.Dom.on_rebootEnum.restart, description="Action lors d'un redémarrage")
    on_crash:configDom.Dom.on_crashEnum = Field(default=configDom.Dom.on_crashEnum.restart, description="Action lors d'un crash de la VM")
    on_failurelock:configDom.Dom.on_failurelockEnum = element(default=configDom.Dom.on_failurelockEnum.ignore, description="A tester")

class DevicesDisk(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    pool_id:UUID4 = Field()
    id:UUID4 = Field()
    size:int = Field()
    unit:configDom.UnitEnum = Field(default=configDom.UnitEnum.GiB)
    bus:configDom.DevicesDiskTarget.busEnum = Field(default=configDom.DevicesDiskTarget.busEnum.scsi)

class DevicesCDROMSource(BaseModel):
    class protocolEnum(str, Enum):
        http = "http"
        https = "https"
        ftp = "ftp"
        ftps = "ftps"

    protocol:protocolEnum = attr(default=protocolEnum.https)
    name:str = attr()

class DevicesCDROM(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    device:configDom.DevicesDisk.deviceEnum = Field(default=configDom.DevicesDisk.deviceEnum.cdrom, json_schema_extra={"hidden": True})
    source:DevicesCDROMSource = element(default=None)

class DevicesInterfaceGuest(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    addr:str = Field()

class DevicesInterface(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    switch_id:UUID4
    id:UUID4
    mac_addr:str = Field()

class Graphics(BaseModel):
    port:int = Field(default=-1)
    autoport:bool = Field(default=False)
    websocket:int = Field(default=-1)
    password:Optional[str] = Field(default=None)
    keymap:configDom.Graphics.keymapEnum = Field(default=configDom.Graphics.keymapEnum.fr)
    power_control:bool = Field(default=False)

class Audio(BaseModel):
    pass

class VideoModel(BaseModel):
    type:configDom.VideoModel.typeEnum = Field(default=configDom.VideoModel.typeEnum.cirrus)
    vram:int = Field(default=16384)
    primary:configDom.YesNoEnum = Field(default=configDom.YesNoEnum.YES)

class Video(BaseModel):
    model:VideoModel = element() 

class Watchdog(BaseModel):
    model:configDom.Watchdog.modelEnum = Field(default=configDom.Watchdog.modelEnum.itco)
    action:configDom.Watchdog.actionEnum = Field(default=configDom.Watchdog.actionEnum.reset)

class TPM(BaseModel):
    model:configDom.TPM.modelEnum = attr(default=configDom.TPM.modelEnum.tpm_tis)
    version:configDom.TPMBackend.versionEnum  = Field(default=configDom.TPMBackend.versionEnum.v20)

class Devices(BaseModel):
    disks:Optional[List[DevicesDisk]] = Field(default=None, description="Disques virtuel")
    cdrom:DevicesCDROM = Field(default=None, description="CDROM virtuel")
    interfaces:Optional[List[DevicesInterface]] = Field(default=None, description="Interfaces réseau")
    graphics:Optional[Graphics] = Field(default=None, description="Console VNC")
    audio:Audio = Field(default=None, description="Carte Audio")
    video:Video = Field(default=None, description="Carte Vidéo")
    watchdog:Watchdog = Field(default=None, description="Chien de garde")
    tpm:TPM = Field(default=None, description="Puce de sécurité")

class VM(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    # General metadata
    id:UUID4 = Field()
    datacenter_id:Optional[UUID4] = Field(default=None)
    name:str = Field()
    description:Optional[str] = Field(default=None)

    # CPU Allocation
    vcpu:VCPU = Field()

    # Memory Allocation
    memory:Memory = Field()

    # Pool of resource (Experimental)
    resource:Resource = Field(default=Resource(), description="Pool de resources")

    # BIOS BootLoader
    os:OS = Field(default=OS(), description="Options VM: Options de démarrage.")

    # Clock configuration
    clock:Clock = Field(default=Clock(), description="Options VM: Gestion de l'horloge")

    # Event configuration
    event:Event = Field(default=Event(), description="Options VM: Gestion des évènements")

    # Devices
    devices:Devices = Field(default=Devices(), description="Matériel virtuel: Périphériques")

"""VM LIST GET"""
class VMs(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    class Datacenter(BaseModel):
        model_config = ConfigDict(from_attributes=True)
        
        id:UUID4
        name:str

    id:UUID4
    name:str
    state:int
    datacenter:Optional[Datacenter] = Field(default=[])

"""VM GET"""
class VMGetVCPU(VCPU):
    max:Optional[int] = Field(default=None, description="Maximum de VCPUs")

class VMGetOS(OS):
    guest_info:Optional[OSInfo] = Field(default=None, description="Information de l'OS client")

class VMGetDevicesDisk(DevicesDisk):
    allocated:float = Field(default=None)

class VMGetDevicesInterface(DevicesInterface):
    guest_info:Optional[List[DevicesInterfaceGuest]] = Field(default=None, description="Information de configuration de la carte réseau.")

class VMGetDevices(Devices):
    disks:Optional[List[VMGetDevicesDisk]] = Field(default=None, description="Disques virtuel")
    interfaces:Optional[List[VMGetDevicesInterface]] = Field(default=None, description="Interfaces réseau")

class VMGet(VM):
    vcpu:VMGetVCPU = Field()
    gen_id:Optional[UUID4] = Field(default=None)
    os:VMGetOS = Field(default=VMGetOS(), description="Options VM: Options de démarrage.")
    devices:VMGetDevices = Field(default=VMGetDevices(), description="Matériel virtuel: Périphériques")

"""VM POST"""
class VMPost(VM):
    id:UUID4 = Field(default_factory=uuid4)
    datacenter_id:UUID4 = Field()

"""VM DELETE"""
class VMDelete(BaseModel):
    id:UUID4 = Field()

class HardDisk(BaseModel):
    pass

class NetInterfaceCreate(BaseModel):
    pass