#/**
#@file    DiskLib.py
#@brief   Librería o clase Disk
#@class   Disk
#@brief   Funciones para gestión de discos y particiones.
#@warning License: GNU GPLv3+
#*/

import filecmp
import subprocess
import shutil
import os
import re
import stat
from pathlib import Path

import ogGlobals
import SystemLib
import CacheLib
import FileSystemLib
import InventoryLib

# Función ficticia para lanzar parted con timeout, evitando cuelgues del programa.
def parted(*args):
    parted_path = shutil.which("parted")
    if parted_path:
        try:
            result = subprocess.run(
                [parted_path] + list(args),
                timeout=3,
                capture_output=True,
                text=True
            )
            return result.stdout
        except subprocess.TimeoutExpired:
            return "Error: Command 'parted' timed out"
    else:
        return "Error: 'parted' command not found"


#/**
#         ogCreatePartitions int_ndisk str_parttype:int_partsize ...
#@brief   Define el conjunto de particiones de un disco.
#@param   int_ndisk      nº de orden del disco
#@param   str_parttype   mnemónico del tipo de partición
#@param   int_partsize   tamaño de la partición (en KB)
#@return  (nada, por determinar)
#@exception OG_ERR_FORMAT    formato incorrecto.
#@exception OG_ERR_NOTFOUND  disco o partición no detectado (no es un dispositivo).
#@exception OG_ERR_PARTITION error en partición o en tabla de particiones.
#@attention El nº de partición se indica por el orden de los párametros \c parttype:partsize
#@attention Pueden definirse particiones vacías de tipo \c EMPTY
#@attention No puede definirse partición de cache y no se modifica si existe.
#@note    Requisitos: sfdisk, parted, partprobe, awk
#@todo    Definir atributos (arranque, oculta) y tamaños en MB, GB, etc.
#*/ ##
def ogCreatePartitions (disk, parts):
    ND = disk
    DISK = ogDiskToDev (ND)
    if not DISK: return None

    PTTYPE = ogGetPartitionTableType (disk)
    if not PTTYPE: PTTYPE = 'MSDOS'  # Por defecto para discos vacíos.

    if 'GPT' == PTTYPE:
        return ogCreateGptPartitions (disk, parts)
    elif 'MSDOS' != PTTYPE:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, PTTYPE)
        return None

    # Se calcula el ultimo sector del disco (total de sectores usables)
    SECTORS = ogGetLastSector (disk)

    # Se recalcula el nº de sectores del disco si existe partición de caché.
    CACHESIZE = 0
    CACHEPART = CacheLib.ogFindCache()
    if CACHEPART:
        cache_disk, cache_part = CACHEPART.split()
        if ND == cache_disk:
            CACHESIZE = int (CacheLib.ogGetCacheSize()) * 2
    # Sector de inicio (la partición 1 empieza en el sector 63).
    IODISCO = ogDiskToDev (disk)
    IOSIZE = 0
    fdisk_out = subprocess.run (['fdisk', '-l', IODISCO], capture_output=True, text=True).stdout
    for l in fdisk_out.splitlines():
        if 'I/O' not in l: continue
        items = l.split()
        if len(items) < 4: continue
        IOSIZE = items[3]
        break

    if '4096' == IOSIZE:
        START = 4096
        SECTORS -= 8192
        if CACHESIZE:
            SECTORS = SECTORS - CACHESIZE + 2048 - (SECTORS - CACHESIZE) % 2048 - 1
    else:
        START = 63
        if CACHESIZE:
            SECTORS -= CACHESIZE

    PART = 1

    sfdisk_input = 'unit: sectors\n\n'
    NVME_PREFIX = 'p' if 'nvme' in DISK else ''
    for p in parts:
        # Conservar los datos de la partición de caché.
        if f'{ND} {PART}' == CACHEPART and CACHESIZE:
            sfdisk_input += f'{DISK}{NVME_PREFIX}{PART} : start={SECTORS+1}, size={CACHESIZE}, Id=ca\n'
            PART += 1

        # Leer formato de cada parámetro - Tipo:Tamaño
        TYPE, SIZE = p.split (':')
        try:
            SIZE = int (SIZE)
        except ValueError:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, SIZE)
            return None

        # Obtener identificador de tipo de partición válido.
        ID = ogTypeToId (TYPE, 'MSDOS')
        if 'CACHE' == TYPE or not ID:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, TYPE)
            return None
        # Comprobar tamaño numérico y convertir en sectores de 512 B.
        SIZE *= 2
        # Comprobar si la partición es extendida.
        EXTSTART = EXTSIZE = 0
        if 5 == ID:
            if PART > 4:
                SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, '')
                return None
            # El inicio de la primera partición logica es el de la extendida más 4x512
            EXTSTART = START+2048
            EXTSIZE = SIZE-2048
        # Incluir particiones lógicas dentro de la partición extendida.
        if 5 == PART:
            if not EXTSTART:
                SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, '')
                return None
            START = EXTSTART
            SECTORS = EXTSTART+EXTSIZE

        # Generar datos para la partición.
        # En el caso de que la partición sea EMPTY no se crea nada
        if 'EMPTY' != TYPE:
            sfdisk_input += f'{DISK}{NVME_PREFIX}{PART} : start={START}, size={SIZE}, Id={ID}\n'

        START += SIZE

        # Error si se supera el nº total de sectores.
        if '4096' == IOSIZE and PART > 4:
            START += 2048
        if START > SECTORS:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'{START//2} > {SECTORS//2}')
            return None
        PART += 1

    # Si no se indican las 4 particiones primarias, definirlas como vacías, conservando la partición de caché.
    while PART <= 4:
        if f'{ND} {PART}' == CACHEPART and CACHESIZE:
            sfdisk_input += f'{DISK}{NVME_PREFIX}{PART} : start={SECTORS+1}, size={CACHESIZE}, Id=ca\n'
        else:
            sfdisk_input += f'{DISK}{NVME_PREFIX}{PART} : start=0, size=0, Id=0\n'
        PART += 1
    # Si se define partición extendida sin lógicas, crear particion 5 vacía.
    if 5 == PART and EXTSTART:
        sfdisk_input += f'{DISK}5 : start={EXTSTART}, SIZE={EXTSIZE}, Id=0\n'

    # Desmontar los sistemas de archivos del disco antes de realizar las operaciones.
    FileSystemLib.ogUnmountAll (ND)
    if CACHESIZE: CacheLib.ogUnmountCache()

    # Si la tabla de particiones no es valida, volver a generarla.
    ogCreatePartitionTable (ND)

    # Definir particiones y notificar al kernel.
    subprocess.run (['sfdisk', DISK], input=sfdisk_input, capture_output=True, text=True)
    subprocess.run (['partprobe', DISK])
    if CACHESIZE: CacheLib.ogMountCache()
    return True


#/**
#         ogCreateGptPartitions int_ndisk str_parttype:int_partsize ...
#@brief   Define el conjunto de particiones de un disco GPT
#@param   int_ndisk      nº de orden del disco
#@param   str_parttype   mnemónico del tipo de partición
#@param   int_partsize   tamaño de la partición (en KB)
#@return  (nada, por determinar)
#@exception OG_ERR_FORMAT    formato incorrecto.
#@exception OG_ERR_NOTFOUND  disco o partición no detectado (no es un dispositivo).
#@exception OG_ERR_PARTITION error en partición o en tabla de particiones.
#@attention El nº de partición se indica por el orden de los párametros \c parttype:partsize
#@attention Pueden definirse particiones vacías de tipo \c EMPTY
#@attention No puede definirse partición de caché y no se modifica si existe.
#@note    Requisitos: sfdisk, parted, partprobe, awk
#@todo    Definir atributos (arranque, oculta) y tamaños en MB, GB, etc.
#*/ ##
def ogCreateGptPartitions (disk, parts):
    ND = disk
    DISK = ogDiskToDev (ND)
    if not DISK: return None

    # Se calcula el ultimo sector del disco (total de sectores usables)
    SECTORS = ogGetLastSector (disk)

    # Se recalcula el nº de sectores del disco si existe partición de caché.
    CACHESIZE = 0
    CACHEPART = CacheLib.ogFindCache()
    if CACHEPART:
        cache_disk, cache_part = CACHEPART.split()
        if ND == cache_disk:
            CACHESIZE = int (CacheLib.ogGetCacheSize()) * 2
        if CACHESIZE:
            SECTORS -= CACHESIZE

    # Si el disco es GPT empieza en el sector 2048  por defecto, pero podria cambiarse
    ALIGN = int (subprocess.run (['sgdisk', '-D', DISK], capture_output=True, text=True).stdout)
    START = ALIGN
    PART = 1

    # Leer parámetros con definición de particionado.
    DELOPTIONS = []
    OPTIONS = []
    for p in parts:
        # Conservar los datos de la partición de caché.
        if f'{ND} {PART}' == CACHEPART and CACHESIZE:
            PART += 1

        # Leer formato de cada parámetro - Tipo:Tamaño
        TYPE, SIZE = p.split (':')
        try:
            SIZE = int (SIZE)
        except ValueError:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, SIZE)
            return None

        # Error si la partición es extendida (no válida en discos GPT).
        if 'EXTENDED' == TYPE:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, 'EXTENDED')
            return None

        # Comprobar si existe la particion actual, capturamos su tamaño para ver si cambio o no
        PARTSIZE = ogGetPartitionSize (ND, PART)
        # En sgdisk no se pueden redimensionar las particiones, es necesario borrarlas y volver a crealas
        if PARTSIZE:
            DELOPTIONS.append (f'-d{PART}')

        # Creamos la particion
        # Obtener identificador de tipo de partición válido.
        ID = ogTypeToId (TYPE, 'GPT')
        if 'CACHE' == TYPE or not ID:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, TYPE)
            return None
        # Comprobar tamaño numérico y convertir en sectores de 512 B.
        SIZE *= 2
        # SIZE debe ser múltiplo de ALIGN, si no gdisk lo mueve automáticamente.
        SIZE = (SIZE // ALIGN) * ALIGN

        # Generar datos para la partición.
        # En el caso de que la partición sea EMPTY no se crea nada
        if 'EMPTY' != TYPE:
            OPTIONS += [f'-n{PART}:{START}:+{SIZE}', f'-t{PART}:{ID}']

        START += SIZE

        # Error si se supera el nº total de sectores.
        if START > SECTORS:
            SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'{START//2} > {SECTORS//2}')
            return None

        PART += 1

    # Desmontar los sistemas de archivos del disco antes de realizar las operaciones.
    FileSystemLib.ogUnmountAll (ND)
    if CACHESIZE: CacheLib.ogUnmountCache()

    # Si la tabla de particiones no es valida, volver a generarla.
    ogCreatePartitionTable (ND, 'GPT')

    # Definir particiones y notificar al kernel.
    subprocess.run (['sgdisk'] + DELOPTIONS + OPTIONS + [DISK])
    subprocess.run (['partprobe', DISK])
    if CACHESIZE: CacheLib.ogMountCache()
    return True


#/**
#         ogCreatePartitionTable int_ndisk [str_tabletype]
#@brief   Genera una tabla de particiones en caso de que no sea valida, si es valida no hace nada.
#@param   int_ndisk      nº de orden del disco
#@param   str_tabletype  tipo de tabla de particiones (opcional)
#@return  (por determinar)
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo.
#@note    tabletype: { MSDOS, GPT }, MSDOS por defecto
#@note    Requisitos: fdisk, gdisk, parted
#*/ ##
def ogCreatePartitionTable (disk, createptt=None):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    pttype = ogGetPartitionTableType (disk) or 'MSDOS'  # Por defecto para discos vacíos.
    createptt = createptt or pttype
    CREATE = None

# Si la tabla actual y la que se indica son iguales, se comprueba si hay que regenerarla.
    if createptt == pttype:
        if 'GPT' == pttype:
            try:
                result = subprocess.run (['sgdisk', '-p', DISK], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                if result.returncode:
                    CREATE = 'GPT'
            except subprocess.CalledProcessError:
                CREATE = 'GPT'
        elif 'MSDOS' == pttype:
            try:
                result = subprocess.run (['parted', '-s', DISK, 'print'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                if result.returncode:
                    CREATE = 'MSDOS'
            except subprocess.CalledProcessError:
                CREATE = 'MSDOS'
    else:
        CREATE = createptt.upper()

# Dependiendo del valor de CREATE, creamos la tabla de particiones en cada caso.
    if 'GPT' == CREATE:
        if 'MSDOS' == pttype:
            subprocess.run (['sgdisk', '-go', DISK])
        else:
            subprocess.run (['gdisk', DISK], input='2\nw\nY\n', text=True)
        subprocess.run (['partprobe', DISK])
    elif 'MSDOS' == CREATE:
        if 'GPT' == pttype:
            subprocess.run (['sgdisk', '-Z', DISK])
        # Crear y borrar una partición para que la tabla se genere bien.
        subprocess.run (['fdisk', DISK], input='o\nn\np\n\n\n\nd\n\nw', text=True)
        subprocess.run (['partprobe', DISK])

    return None


#/**
#         ogDeletePartitionTable ndisk
#@brief   Borra la tabla de particiones del disco.
#@param   int_ndisk      nº de orden del disco
#@return  la informacion propia del fdisk
#*/ ##
def ogDeletePartitionTable (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    PTTYPE = ogGetPartitionTableType (disk)
    if 'GPT' == PTTYPE:
        subprocess.run (['sgdisk', '--clear', DISK])
    elif 'MSDOS' == PTTYPE:
        subprocess.run (['fdisk', DISK], input='o\nw', text=True)
    return

#/**
#         ogDevToDisk path_device | LABEL="str_label" | UUID="str_uuid"
#@brief   Devuelve el nº de orden de dicso (y partición) correspondiente al nombre de fichero de dispositivo o a la etiqueta o UUID del sistema de archivos asociado.
#@param   path_device  Camino del fichero de dispositivo.
#@param   str_label    etiqueta de sistema de archivos.
#@param   str_uuid     UUID de sistema de archivos.
#@return  int_ndisk (para dispositivo de disco)
#@return  int_ndisk int_npartition (para dispositivo de partición).
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Dispositivo no detectado.
#@note    Solo se acepta en cada llamada 1 de los 3 tipos de parámetros.
#*/ ##
def ogDevToDisk(arg_dev):
    CACHEFILE = "/var/cache/disks.cfg"

    if '=' in arg_dev:
        # arg_dev is "FOO=bar"
        cmd = None
        if   arg_dev.startswith("LABEL="):     cmd = ['blkid', '-L', arg_dev[6:]]
        elif arg_dev.startswith("PARTLABEL="): cmd = ['realpath', '/dev/disk/by-partlabel/'+arg_dev[11:]]
        elif arg_dev.startswith("PARTUUID="):  cmd = ['realpath', '/dev/disk/by-partuuid/'+arg_dev[10:]]
        elif arg_dev.startswith("UUID="):      cmd = ['blkid', '-U', arg_dev[5:]]
        if not cmd:
            SystemLib.ogRaiseError([], ogGlobals.OG_ERR_FORMAT, arg_dev)
            return
        DEV = subprocess.run (cmd, capture_output=True, text=True).stdout.strip()
    else:
        # arg_dev is "/dev/something"
        DEV = arg_dev

    if not os.path.exists(DEV):
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_dev)
        return

    # Error si no es fichero de bloques o directorio (para LVM).
    m = os.stat (DEV, follow_symlinks=True).st_mode
    if not stat.S_ISBLK (m) and not stat.S_ISDIR (m):
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_dev)
        return

    # Buscar en fichero de caché de discos.
    PART = None
    if os.path.exists(CACHEFILE):
        with open(CACHEFILE, 'r') as f:
            for line in f:
                parts = line.strip().split(':')
                if len(parts) == 2 and parts[1] == DEV:
                    PART = parts[0]
                    break

    if PART: return PART

    # Si no se encuentra, procesa todos los discos para devolver su nº de orden y de partición.
    disks = ogDiskToDev()
    n = 1
    for d in disks:
        NVME_PREFIX = "p" if "nvme" in d else ""
        if DEV.startswith(d):
            return f"{n} {DEV[len(d) + len(NVME_PREFIX):]}"
        n += 1

    SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_dev)
    return

def _getAllDisks():
    ret = []
    all_disks = subprocess.run("lsblk -n -e 1,2 -x MAJ:MIN 2>/dev/null || lsblk -n -e 1,2", shell=True, capture_output=True, text=True).stdout.splitlines()
    for line in all_disks:
        parts = line.split()
        if parts[5] == "disk":
            parts[0].replace ('!', '/')
            ret.append(f"/dev/{parts[0]}")
    return ret

def _getAllVolGroups():
    vgs = subprocess.run(['vgs', '-a', '--noheadings'], capture_output=True, text=True).stdout.splitlines()
    ret = [f"/dev/{line.split()[0]}" for line in vgs]
    return ret

def _getMPath():
    ret = alldisks2remove = []
    try:
        mpath = subprocess.run(['multipath', '-l', '-v', '1'], capture_output=True, text=True).stdout.splitlines()
        ret = [f"/dev/mapper/{line.split()[0]}" for line in mpath]
        for line in subprocess.getoutput("multipath -ll").splitlines():
            if line.split()[5] == "ready":
                alldisks2remove.append (f"/dev/{line.split()[2]}")
    except FileNotFoundError:
        pass
    except subprocess.CalledProcessError:
        pass
    return ret, alldisks2remove

def _getAllZFSVols():
    zfsvols = subprocess.run(['blkid'], capture_output=True, text=True).stdout.splitlines()
    return [line.split(":")[0] for line in zfsvols if "zfs" in line]

#/**
#         ogDiskToDev [int_ndisk [int_npartition]]
#@brief   Devuelve la equivalencia entre el nº de orden del dispositivo (dicso o partición) y el nombre de fichero de dispositivo correspondiente.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  Para 0 parametros: Devuelve los nombres de ficheros  de los dispositivos sata/ata/usb linux encontrados.
#@return  Para 1 parametros: Devuelve la ruta del disco duro indicado.
#@return  Para 2 parametros: Devuelve la ruta de la particion indicada.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Dispositivo no detectado.
#*/ ##
def ogDiskToDev (arg_disk=None, arg_part=None):
    CACHEFILE = "/var/cache/disks.cfg"

    try:
        if arg_part != None:
            arg_part = int (arg_part)
    except:
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_FORMAT, f"{arg_disk} {arg_part}")
        return

    try:
        if arg_disk != None:
            arg_disk = int (arg_disk)
    except:
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_FORMAT, arg_disk)
        return

    # Borrar fichero de caché de configuración si hay cambios en las particiones.
    proc_partitions = Path ('/proc/partitions').read_text()
    tmp_partitions  = Path ('/tmp/.partitions').read_text() if os.path.exists ('/tmp/.partitions') else ''
    if proc_partitions != tmp_partitions:
        # Guardar copia de las particiones definidas para comprobar cambios.
        shutil.copy2('/proc/partitions', '/tmp/.partitions')
        try:
            os.remove(CACHEFILE)
        except FileNotFoundError:
            pass

    # Si existe una correspondencia con disco/dispositivo en el caché; mostrarlo y salir.
    if arg_disk and os.path.exists (CACHEFILE):
        with open(CACHEFILE, 'r') as f:
            args_joined = ' '.join (map (str, filter (None, [arg_disk,arg_part])))
            for line in f:
                parts = line.strip().split(':')
                if len(parts) == 2 and parts[0] == args_joined:
                    return parts[1]

    # Continuar para detectar nuevos dispositivos.

    ALLDISKS = _getAllDisks()

    VOLGROUPS = _getAllVolGroups()
    ALLDISKS += VOLGROUPS

    MPATH, ALLDISKS_to_remove =_getMPath()
    for d in ALLDISKS_to_remove:
        if d in ALLDISKS: ALLDISKS.remove (d)

    ZFSVOLS = _getAllZFSVols()
    ALLDISKS += ZFSVOLS

    # No params: return all disks
    if arg_disk is None:
        return ALLDISKS

    # arg_disk is set: return it
    if arg_part is None:
        if arg_disk > len (ALLDISKS):
            SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_disk)
            return
        disk = ALLDISKS[arg_disk-1]
        if not os.path.exists(disk):
            SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_disk)
            return
        # Actualizar caché de configuración y mostrar dispositivo.
        with open(CACHEFILE, 'a') as f:
            f.write(f"{arg_disk}:{disk}\n")
        return disk

    # arg_disk and arg_part are set: there are several possibilities
    if arg_disk > len (ALLDISKS):
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_disk)
        return
    disk = ALLDISKS[arg_disk-1]
    if not os.path.exists(disk):
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, arg_disk)
        return

    # Plain partition
    part = f"{disk}{arg_part}"
    if os.path.exists(part):
        # Actualizar caché de configuración y mostrar dispositivo.
        with open(CACHEFILE, 'a') as f:
            f.write(f"{arg_disk} {arg_part}:{part}\n")
        return part

    # RAID/Multipath (tener en cuenta enlace simbólico).
    part = f"{disk}p{arg_part}"
    if os.path.exists(part) and stat.S_ISBLK (os.stat (part, follow_symlinks=True).st_mode):
        # Actualizar caché de configuración y mostrar dispositivo.
        with open(CACHEFILE, 'a') as f:
            f.write(f"{arg_disk} {arg_part}:{part}\n")
        return part

    part = ""
    # Logical volume
    if disk in VOLGROUPS:
        lvscan = subprocess.run (['lvscan', '-a'], capture_output=True, text=True).stdout.splitlines()
        i = 0
        for line in lvscan:
            parts = line.split("'")
            if parts[1].startswith(f"{disk}/") and i == arg_part:
                part = parts[1]
                break
            i += 1

    # ZFS volume
    if disk in ZFSVOLS:
        subprocess.run(["zpool", "import", "-f", "-R", "/mnt", "-N", "-a"])
        zpool = subprocess.run(['blkid', '-s', 'LABEL', '-o', 'value', disk], capture_output=True, text=True).stdout
        zfs_list = subprocess.run(['zfs', 'list', '-Hp', '-o', 'name,canmount,mountpoint', '-r', zpool], capture_output=True, text=True).stdout.splitlines()
        i = 0
        for line in zfs_list:
            parts = line.split()
            if parts[1] == "on" and parts[2] != "none":
                if i == int(args[1]):
                    part = parts[0]
                    break
                i += 1

    if not part:
        SystemLib.ogRaiseError([], ogGlobals.OG_ERR_NOTFOUND, f"{arg_disk} {arg_part}")
        return

    # Actualizar caché de configuración y mostrar dispositivo.
    with open(CACHEFILE, 'a') as f:
        f.write(f"{arg_disk} {arg_part}:{part}\n")

    return part


#/**
#         ogGetDiskSize int_ndisk
#@brief   Muestra el tamaño en KB de un disco.
#@param   int_ndisk   nº de orden del disco
#@return  int_size  - Tamaño en KB del disco.
#@exception OG_ERR_FORMAT   formato incorrecto.
#@exception OG_ERR_NOTFOUND disco o particion no detectado (no es un dispositivo).
#@note    Requisitos: sfdisk, awk
#*/ ##
def ogGetDiskSize (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    bn = os.path.basename (DISK)
    SIZE = None
    with open ('/proc/partitions', 'r') as fd:
        while True:
            l = fd.readline()
            if not l: break
            items = l.split()
            if len(items) < 4: continue
            if items[3] == bn:
                SIZE = int (items[2])
                break
    if not SIZE:
        vgs_out = subprocess.run (['vgs', '--noheadings', '--units=B', '-o', 'dev_size', DISK], capture_output=True, text=True).stdout
        items = vgs_out.split()
        SIZE = int (items[0]) // 1024

    return SIZE


#/**
#         ogGetDiskType path_device
#@brief   Muestra el tipo de disco (real, RAID, meta-disco, USB, etc.).
#@param   path_device  Dispositivo
#@exception OG_ERR_FORMAT   formato incorrecto.
#@exception OG_ERR_NOTFOUND disco no detectado o no es un dispositivo de bloques.
#@note    Requisitos: udevadm
#*/ ##
def ogGetDiskType (dev):
    DEV = os.path.basename (dev)

    bn = os.path.basename (DEV)
    MAJOR = None
    with open ('/proc/partitions', 'r') as fd:
        while True:
            l = fd.readline()
            if not l: break
            items = l.split()
            if len(items) < 4: continue
            if items[3] == bn:
                MAJOR = items[0]
                break

    TYPE = None
    with open ('/proc/devices', 'r') as fd:
        within_block_section = False
        while True:
            l = fd.readline()
            if not l: break

            if 'Block' in l:
                within_block_section = True
                continue
            if not within_block_section:
                continue

            items = l.split()
            if len(items) < 2: continue
            if items[0] == MAJOR:
                TYPE = items[1].upper()
                break

    # Devolver mnemónico del driver de dispositivo.
    if 'SD' == TYPE:
        TYPE = 'DISK'
        udevadm_out = subprocess.run (['udevadm', 'info', '-q', 'property', dev], capture_output=True, text=True).stdout
        for l in udevadm_out.splitlines():
            if 'ID_BUS=usb' == l[0:10]:
                TYPE = 'USB'
    elif 'BLKEXT' == TYPE:
        TYPE = 'NVM'
    elif 'SR' == TYPE or TYPE.startswith ('IDE'):
        TYPE = 'CDROM'  # FIXME Comprobar discos IDE.
    elif 'MD' == TYPE or TYPE.startswith ('CCISS'):
        TYPE = 'RAID'
    elif 'DEVICE-MAPPER' == TYPE:
        TYPE = 'MAPPER'  # FIXME Comprobar LVM y RAID.

    return TYPE


#/**
#         ogGetEsp
#@brief   Devuelve números de disco y partición para la partición EFI (ESP).
#*/ ##
def ogGetEsp():
    devices = subprocess.run (['blkid', '-o', 'device'], capture_output=True, text=True).stdout.splitlines()
    devices.sort()
    for d in devices:
        # Previene error para /dev/loop0
        PART = ogDevToDisk (d)
        if not PART: continue

        # En discos NVMe blkid devuelve una salida del tipo:
        #    >/dev/loop0
        #    >/dev/nvme0n1
        #    >/dev/nvme0n1p1
        # al analizar la particion nvme0n1, PART solo tiene un argumento y hace que ogGetPartitionId lance un error
        if len (PART) > 1:
            disk, par = PART.split()
            if ogGetPartitionId (disk, par) == ogTypeToId ('EFI', 'GPT'):
                return PART
    return None


#/**
#         ogGetLastSector int_ndisk [int_npart]
#@brief   Devuelve el último sector usable del disco o de una partición.
#@param   int_ndisk      nº de orden del disco
#@param   int_npart      nº de orden de la partición (opcional)
#@return  Último sector usable.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o partición no corresponde con un dispositivo.
#@note    Requisitos: sfdisk, sgdisk
#*/ ##
def ogGetLastSector (disk, par=None):
    DISK = ogDiskToDev (disk)
    if not DISK: return None
    env = os.environ
    env['LANG'] = 'C'
    last = None
    if par:
        PART = ogDiskToDev (disk, par)
        if not PART: return None
        sgdisk_out = subprocess.run (['sgdisk', '-p', DISK], env=env, capture_output=True, text=True).stdout
        for l in sgdisk_out.splitlines():
            items = l.split()
            if len(items) < 3: continue
            if str (par) != items[0]: continue
            last = int (items[2])
            break

    else:
        sgdisk_out = subprocess.run (['sgdisk', '-p', DISK], env=env, capture_output=True, text=True).stdout
        for l in sgdisk_out.splitlines():
            if 'last usable sector' not in l: continue
            items = l.split()
            last = int (items[-1])

    return last


#/**
#         ogGetPartitionActive int_ndisk
#@brief   Muestra que particion de un disco esta marcada como de activa.
#@param   int_ndisk   nº de orden del disco
#@exception OG_ERR_FORMAT Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo.
#@note    Requisitos: parted
#@todo    Queda definir formato para atributos (arranque, oculta, ...).
#*/ ##
def ogGetPartitionActive (disk):
    DISK = ogDiskToDev (disk)
    if DISK is None: return

    if 'LANG' in os.environ:
        lang = os.environ['LANG']

    ret = None
    os.environ['LANG'] = 'C'
    lines = subprocess.run (['parted', '--script', '--machine', DISK, 'print'], capture_output=True, text=True).stdout.splitlines()
    for line in lines:
        parts = line.split (':')
        if len (parts) < 6: continue
        if 'boot' in parts[6]:
            ret = parts[0]
            break

    if lang is None:
        del os.environ['LANG']
    else:
        os.environ['LAMG'] = lang

    return ret


#/**
#         ogGetPartitionId int_ndisk int_npartition
#@brief   Devuelve el mnemónico con el tipo de partición.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  Identificador de tipo de partición.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o partición no corresponde con un dispositivo.
#@note    Requisitos: sfdisk
#*/ ##
def ogGetPartitionId (disk, par):
    DISK = ogDiskToDev (disk)
    if DISK is None: return
    fsid = None

    pttype = ogGetPartitionTableType (disk)
    if 'GPT' == pttype:
        lines = subprocess.run (['sgdisk', '-p', DISK], capture_output=True, text=True).stdout.splitlines()
        start_index = next (i for i, line in enumerate(lines) if 'Number' in line)
        for l in lines[start_index:]:
            idx, start, end, sz, sz_units, code, *rest = l.split()
            if idx == str(par):
                fsid = code
                break
        if fsid == '8300' and f'{disk} {par}' == CacheLib.ogFindCache():
            fsid = 'CA00'
    elif 'MSDOS' == pttype:
        fsid = subprocess.run (['sfdisk', '--part-type', DISK, par], capture_output=True, text=True).stdout.strip()
    elif 'LVM' == pttype:
        fsid = '10000'
    elif 'ZPOOL' == pttype:
        fsid = '10010'

    return fsid


#/**
#         ogGetPartitionSize int_ndisk int_npartition
#@brief   Muestra el tamano en KB de una particion determinada.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  int_partsize - Tamaño en KB de la partición.
#@exception OG_ERR_FORMAT   formato incorrecto.
#@exception OG_ERR_NOTFOUND disco o particion no detectado (no es un dispositivo).
#@note    Requisitos: sfdisk, awk
#*/ ##
def ogGetPartitionSize (disk, par):
    PART = ogDiskToDev (disk, par)
    if PART is None: return

    sz = subprocess.run (['partx', '-gbo', 'SIZE', PART], capture_output=True, text=True).stdout.strip()
    if sz: return int (int (sz) / 1024)

    sz = subprocess.run (['lvs', '--noheadings', '-o', 'lv_size', '--units', 'k', PART], capture_output=True, text=True).stdout.strip()
    if sz: return int (sz)

    return FileSystemLib.ogGetFsSize (disk, par)


#/**
#         ogGetPartitionsNumber int_ndisk
#@brief   Detecta el numero de particiones del disco duro indicado.
#@param   int_ndisk      nº de orden del disco
#@return  Devuelve el numero paritiones del disco duro indicado
#@warning Salidas de errores no determinada
#@attention Requisitos: parted
#@note	  Notas sin especificar
#*/ ##
def ogGetPartitionsNumber (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None
    out = 0

    pttype = ogGetPartitionTableType (disk)
    if pttype in ['GPT', 'MSDOS']:
        partx_out = subprocess.run (['partx', '-gso', 'NR', DISK], capture_output=True, text=True).stdout
        lines = partx_out.splitlines()
        if len(lines):
            out = lines[-1].strip()
    elif 'LVM' == pttype:
        lvs_out = subprocess.run (['lvs', '--noheadings', DISK], capture_output=True, text=True).stdout
        lines = lvs_out.splitlines()
        out = len (lines)
    elif 'ZPOOL' == pttype:
        if subprocess.run (['zpool', 'list']).returncode:
            subprocess.run (['modprobe', 'zfs'])
        subprocess.run (['zpool', 'import', '-f', '-R', '/mnt', '-N', '-a'])
        blkid = subprocess.run (['blkid', '-s', 'LABEL', '-o', 'value', DISK], capture_output=True, text=True).stdout
        zfs_out = subprocess.run (['zfs', 'list', '-Hp', '-o', 'name,canmount,mountpoint', '-r', blkid], capture_output=True, text=True).stdout
        out = 0
        for l in zfs_out.splitlines():
            items = l.split()
            if len(items) < 3: continue
            if 'on' == items[1] and 'none' != items[2]: out += 1

    return int (out)


#/**
#         ogGetPartitionTableType int_ndisk
#@brief   Devuelve el tipo de tabla de particiones del disco (GPT o MSDOS)
#@param   int_ndisk       nº de orden del disco
#@return  str_tabletype - Tipo de tabla de paritiones
#@warning Salidas de errores no determinada
#@note    tabletype = { MSDOS, GPT }
#@note    Requisitos: blkid, parted, vgs
#*/ ##
def ogGetPartitionTableType (disk):
    DISK = ogDiskToDev (disk)
    if DISK is None: return

    m = os.stat (DISK, follow_symlinks=True).st_mode
    if stat.S_ISBLK (m):
        lines = subprocess.run (['parted', '--script', '--machine', DISK, 'print'], capture_output=True, text=True).stdout.splitlines()
        for l in lines:
            elems = l.split (':')
            if DISK == elems[0]:
                type = elems[5].upper()
                break

    # Comprobar si es volumen lógico.
    if os.path.isdir (DISK) and 0 == subprocess.run (['vgs', DISK]).returncode:
        type = 'LVM'

    # Comprobar si es pool de ZFS.
    if not type or 'UNKNOWN' == type:
        if 'zfs' in subprocess.run (['blkid', '-s', 'TYPE', DISK], capture_output=True, text=True).stdout:
            type = 'ZPOOL'

    return type


#/**
#         ogGetPartitionType int_ndisk int_npartition
#@brief   Devuelve el mnemonico con el tipo de partición.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  Mnemonico
#@note    Mnemonico: valor devuelto por ogIdToType.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo.
#*/ ##
def ogGetPartitionType (disk, par):
    ID = ogGetPartitionId (disk, par)
    if ID is None: return None

    return ogIdToType (ID)


#/**
#         ogHidePartition int_ndisk int_npartition
#@brief   Oculta un apartición visible.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  (nada)
#@exception OG_ERR_FORMAT    formato incorrecto.
#@exception OG_ERR_NOTFOUND  disco o particion no detectado (no es un dispositivo).
#@exception OG_ERR_PARTITION tipo de partición no reconocido.
#*/ ##
def ogHidePartition (disk, par):
    PART = ogDiskToDev (disk, par)
    if not PART: return None

    TYPE = ogGetPartitionType (disk, par)
    if   'NTFS'    == TYPE: NEWTYPE = 'HNTFS'
    elif 'FAT32'   == TYPE: NEWTYPE = 'HFAT32'
    elif 'FAT16'   == TYPE: NEWTYPE = 'HFAT16'
    elif 'FAT12'   == TYPE: NEWTYPE = 'HFAT12'
    elif 'WINDOWS' == TYPE: NEWTYPE = 'WIN-RESERV'
    else:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, TYPE)
        return None

    ogSetPartitionType (disk, par, NEWTYPE)


#/**
#         ogIdToType int_idpart
#@brief   Devuelve el identificador correspondiente a un tipo de partición.
#@param   int_idpart    identificador de tipo de partición.
#@return  str_parttype  mnemónico de tipo de partición.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#*/ ##
def ogIdToType (ID):
    # Obtener valor hexadecimal de 4 caracteres rellenado con 0 por delante.
    ID = ID.zfill(4).lower()

    id2type = {
        '0000':    'EMPTY',
        '0001':    'FAT12',
        '0005':    'EXTENDED',
        '000f':    'EXTENDED',
        '0006':    'FAT16',
        '000e':    'FAT16',
        '0007':    'NTFS',
        '000b':    'FAT32',
        '000c':    'FAT32',
        '0011':    'HFAT12',
        '0012':    'COMPAQDIAG',
        '0016':    'HFAT16',
        '001e':    'HFAT16',
        '0017':    'HNTFS',
        '001b':    'HFAT32',
        '001c':    'HFAT32',
        '0042':    'WIN-DYNAMIC',
        '0082':    'LINUX-SWAP',
        '8200':    'LINUX-SWAP',
        '0083':    'LINUX',
        '8300':    'LINUX',
        '008e':    'LINUX-LVM',
        '8E00':    'LINUX-LVM',
        '00a5':    'FREEBSD',
        'a503':    'FREEBSD',
        '00a6':    'OPENBSD',
        '00a7':    'CACHE',  # (compatibilidad con Brutalix)
        '00af':    'HFS',
        'af00':    'HFS',
        '00be':    'SOLARIS-BOOT',
        'be00':    'SOLARIS-BOOT',
        '00bf':    'SOLARIS',
        'bf00145': 'SOLARIS',
        '00ca':    'CACHE',
        'ca00':    'CACHE',
        '00da':    'DATA',
        '00ee':    'GPT',
        '00ef':    'EFI',
        'ef00':    'EFI',
        '00fb':    'VMFS',
        '00fd':    'LINUX-RAID',
        'fd00':    'LINUX-RAID',
        '0700':    'WINDOWS',
        '0c01':    'WIN-RESERV',
        '7f00':    'CHROMEOS-KRN',
        '7f01':    'CHROMEOS',
        '7f02':    'CHROMEOS-RESERV',
        '8301':    'LINUX-RESERV',
        'a500':    'FREEBSD-DISK',
        'a501':    'FREEBSD-BOOT',
        'a502':    'FREEBSD-SWAP',
        'ab00':    'HFS-BOOT',
        'af01':    'HFS-RAID',
        'bf02':    'SOLARIS-SWAP',
        'bf03':    'SOLARIS-DISK',
        'ef01':    'MBR',
        'ef02':    'BIOS-BOOT',
        '10000':   'LVM-LV',
        '10010':   'ZFS-VOL',
    }
    if ID in id2type:
        return id2type[ID]
    return 'UNKNOWN'


#         ogIsDiskLocked int_ndisk
#@brief   Comprueba si un disco está bloqueado por una operación de uso exclusivo.
#@param   int_ndisk      nº de orden del disco
#@return  Código de salida: 0 - bloqueado, 1 - sin bloquear o error.
#@note    Los ficheros de bloqueo se localizan en \c /var/lock/dev, siendo \c dev el dispositivo de la partición o de su disco, sustituyendo el carácter "/" por "-".
#*/ ##
def ogIsDiskLocked (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return False
    return os.path.isfile (f'/var/lock/lock{DISK.replace("/", "-")}')


#/**
#         ogListPartitions int_ndisk
#@brief   Lista las particiones definidas en un disco.
#@param   int_ndisk  nº de orden del disco
#@return  str_parttype:int_partsize ...
#@exception OG_ERR_FORMAT   formato incorrecto.
#@exception OG_ERR_NOTFOUND disco o particion no detectado (no es un dispositivo).
#@note    Requisitos: \c parted \c awk
#@attention El nº de partición se indica por el orden de los párametros \c parttype:partsize
#@attention Las tuplas de valores están separadas por espacios.
#*/ ##
def ogListPartitions (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    p = []
    NPARTS = ogGetPartitionsNumber (disk)
    for PART in range (1, NPARTS + 1):
        t = ogGetPartitionType (disk, PART)
        TYPE = ogGetPartitionType (disk, PART) or 'EMPTY'
        SIZE = ogGetPartitionSize (disk, PART) or 0
        p.append (f'{TYPE}:{SIZE}')

    return p


#/**
#         ogListPrimaryPartitions int_ndisk
#@brief   Metafunción que lista las particiones primarias no vacías de un disco.
#@param   int_ndisk  nº de orden del disco
#@see     ogListPartitions
#*/ ##
def ogListPrimaryPartitions (disk):
    PTTYPE = ogGetPartitionTableType (disk)
    if not PTTYPE: return None

    PARTS = ogListPartitions (disk)
    if not PARTS: return None

    if 'GPT' == PTTYPE:
        res = []
        for idx in range (len(PARTS),0,-1):
            item = PARTS[idx-1]
            if 0==len(res) and 'EMPTY:0' == item: continue
            res.insert (0, item)
        return res
    elif 'MSDOS' == PTTYPE:
        return PARTS[0:4]


#/**
#         ogListLogicalPartitions int_ndisk
#@brief   Metafunción que lista las particiones lógicas de una tabla tipo MSDOS.
#@param   int_ndisk  nº de orden del disco
#@see     ogListPartitions
#*/ ##
def ogListLogicalPartitions (disk):
    PTTYPE = ogGetPartitionTableType (disk)
    if not PTTYPE: return None

    PARTS = ogListPartitions (disk)
    if not PARTS: return None

    return PARTS[4:]


#/**
#         ogLockDisk int_ndisk
#@brief   Genera un fichero de bloqueo para un disco en uso exlusivo.
#@param   int_ndisk      nº de orden del disco
#@return  (nada)
#@exception OG_ERR_FORMAT    Formato incorrecto.
#@exception OG_ERR_NOTFOUND  Disco o particion no corresponden con un dispositivo.
#@note    El fichero de bloqueo se localiza en \c /var/lock/disk, siendo \c disk el dispositivo del disco, sustituyendo el carácter "/" por "-".
#*/ ##
def ogLockDisk (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None
    open (f'/var/lock/lock{DISK.replace("/", "-")}', 'a').close()


#/**
#         ogSetPartitionActive int_ndisk int_npartition
#@brief   Establece cual es la partición activa de un disco.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  (nada).
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@exception OG_ERR_NOTFOUND Disco o partición no corresponden con un dispositivo.
#@note    Requisitos: parted
#*/ ##
def ogSetPartitionActive (disk, par):
    if InventoryLib.ogIsEfiActive():
        SystemLib.ogEcho (['session', 'log'], 'warning', f'EFI: {ogGlobals.lang.MSG_DONTUSE} ogSetPartitionActive')
        return

    DISK = ogDiskToDev (disk)
    if DISK is None: return

    PART = ogDiskToDev (disk, par)
    if PART is None: return

    subprocess.run (["parted", "-s", DISK, "set", par, "boot", "on"])
    return


#/**
#         ogSetPartitionId int_ndisk int_npartition hex_partid
#@brief   Cambia el identificador de la partición.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@param   hex_partid     identificador de tipo de partición
#@return  (nada)
#@exception OG_ERR_FORMAT     Formato incorrecto.
#@exception OG_ERR_NOTFOUND   Disco o partición no corresponden con un dispositivo.
#@exception OG_ERR_OUTOFLIMIT Valor no válido.
#@exception OG_ERR_PARTITION  Error al cambiar el id. de partición.
#@attention Requisitos: fdisk, sgdisk
#*/ ##
def ogSetPartitionId (disk, par, id):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    PART = ogDiskToDev (disk, par)
    if not PART: return None

# Error si el id. de partición no es hexadecimal.
    if not re.match ('^[0-9A-Fa-f]+$', id):
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_OUTOFLIMIT, id)
        return None

# Elección del tipo de partición.
    PTTYPE = ogGetPartitionTableType (disk)
    if 'GPT' == PTTYPE:
        p = subprocess.run (['sgdisk', f'-t{par}:{id.upper()}', DISK])
    elif 'MSDOS' == PTTYPE:
        p = subprocess.run (['sfdisk', '--id', DISK, par, id.upper()])
    else:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_OUTOFLIMIT, f'{disk},{PTTYPE}')
        return None

# MSDOS) Correcto si fdisk sin error o con error pero realiza Syncing
    if 0 == p.returncode:
        subprocess.run (['partprobe', DISK])
        return True
    else:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, f'{disk},{part},{id}')
        return None


#/**
#         ogSetPartitionSize int_ndisk int_npartition int_size
#@brief   Muestra el tamano en KB de una particion determinada.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@param   int_size       tamaño de la partición (en KB)
#@return  (nada)
#@exception OG_ERR_FORMAT   formato incorrecto.
#@exception OG_ERR_NOTFOUND disco o particion no detectado (no es un dispositivo).
#@note    Requisitos: sfdisk, awk
#@todo    Compruebar que el tamaño sea numérico positivo y evitar que pueda solaparse con la siguiente partición.
#*/ ##
def ogSetPartitionSize (disk, par, size):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    PART = ogDiskToDev (disk, par)
    if not PART: return None

# Convertir tamaño en KB a sectores de 512 B.
    SIZE = 2 * int (size)
# Redefinir el tamaño de la partición.
    p = subprocess.run (['sfdisk', '-f', '-uS', f'-N{par}', DISK], input=f',{SIZE}', text=True)
    if p.returncode:
        ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, f'{disk},{par}')
        return None
    subprocess.run (['partprobe', DISK])


#/**
#         ogSetPartitionType int_ndisk int_npartition str_type
#@brief   Cambia el identificador de la partición.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@param   str_type       mnemónico de tipo de partición
#@return  (nada)
#@attention Requisitos: fdisk, sgdisk
#*/ ##
def ogSetPartitionType (disk, par, t):
    DISK = ogDiskToDev (disk)
    if not DISK: return None

    PART = ogDiskToDev (disk, par)
    if not PART: return None

    PTTYPE = ogGetPartitionTableType (disk)
    if not PTTYPE: return None

    ID = ogTypeToId (t, PTTYPE)
    if not ID:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'{t},{PTTYPE}')
        return None

    ogSetPartitionId (disk, par, ID)


#/**
#         ogTypeToId str_parttype [str_tabletype]
#@brief   Devuelve el identificador correspondiente a un tipo de partición.
#@param   str_parttype  mnemónico de tipo de partición.
#@param   str_tabletype mnemónico de tipo de tabla de particiones (MSDOS por defecto).
#@return  int_idpart    identificador de tipo de partición.
#@exception OG_ERR_FORMAT   Formato incorrecto.
#@note    tabletype = { MSDOS, GPT },   (MSDOS, por defecto)
#*/ ##
#ogTypeToId ('LINUX')           =>  "83"
#ogTypeToId ('LINUX', 'MSDOS')  =>  "83"
def ogTypeToId (type, pttype='MSDOS'):
    data = {
        'GPT': {
            'EMPTY':           '0',
            'WINDOWS':         '0700',
            'NTFS':            '0700',
            'EXFAT':           '0700',
            'FAT32':           '0700',
            'FAT16':           '0700',
            'FAT12':           '0700',
            'HNTFS':           '0700',
            'HFAT32':          '0700',
            'HFAT16':          '0700',
            'HFAT12':          '0700',
            'WIN-RESERV':      '0C01',
            'CHROMEOS-KRN':    '7F00',
            'CHROMEOS':        '7F01',
            'CHROMEOS-RESERV': '7F02',
            'LINUX-SWAP':      '8200',
            'LINUX':           '8300',
            'EXT2':            '8300',
            'EXT3':            '8300',
            'EXT4':            '8300',
            'REISERFS':        '8300',
            'REISER4':         '8300',
            'XFS':             '8300',
            'JFS':             '8300',
            'LINUX-RESERV':    '8301',
            'LINUX-LVM':       '8E00',
            'FREEBSD-DISK':    'A500',
            'FREEBSD-BOOT':    'A501',
            'FREEBSD-SWAP':    'A502',
            'FREEBSD':         'A503',
            'HFS-BOOT':        'AB00',
            'HFS':             'AF00',
            'HFS+':            'AF00',
            'HFSPLUS':         'AF00',
            'HFS-RAID':        'AF01',
            'SOLARIS-BOOT':    'BE00',
            'SOLARIS':         'BF00',
            'SOLARIS-SWAP':    'BF02',
            'SOLARIS-DISK':    'BF03',
            'CACHE':           'CA00',
            'EFI':             'EF00',
            'LINUX-RAID':      'FD00',
        },
        'MSDOS': {
            'EMPTY':           '0',
            'FAT12':           '1',
            'EXTENDED':        '5',
            'FAT16':           '6',
            'WINDOWS':         '7',
            'NTFS':            '7',
            'EXFAT':           '7',
            'FAT32':           'b',
            'HFAT12':          '11',
            'HFAT16':          '16',
            'HNTFS':           '17',
            'HFAT32':          '1b',
            'LINUX-SWAP':      '82',
            'LINUX':           '83',
            'EXT2':            '83',
            'EXT3':            '83',
            'EXT4':            '83',
            'REISERFS':        '83',
            'REISER4':         '83',
            'XFS':             '83',
            'JFS':             '83',
            'LINUX-LVM':       '8e',
            'FREEBSD':         'a5',
            'OPENBSD':         'a6',
            'HFS':             'af',
            'HFS+':            'af',
            'SOLARIS-BOOT':    'be',
            'SOLARIS':         'bf',
            'CACHE':           'ca',
            'DATA':            'da',
            'GPT':             'ee',
            'EFI':             'ef',
            'VMFS':            'fb',
            'LINUX-RAID':      'fd',
        },
        'LVM': {
            'LVM-LV':          '10000',
        },
        'ZVOL': {
            'ZFS-VOL':         '10010',
        },
    }

    if pttype.upper() not in data:               return None
    if type.upper() not in data[pttype.upper()]: return None
    return data[pttype.upper()][type.upper()]


#/**
#         ogUnhidePartition int_ndisk int_npartition
#@brief   Hace visible una partición oculta.
#@param   int_ndisk      nº de orden del disco
#@param   int_npartition nº de orden de la partición
#@return  (nada)
#@exception OG_ERR_FORMAT    formato incorrecto.
#@exception OG_ERR_NOTFOUND  disco o particion no detectado (no es un dispositivo).
#@exception OG_ERR_PARTITION tipo de partición no reconocido.
#*/ ##
def ogUnhidePartition (disk, par):
    PART = ogDiskToDev (disk, par)
    if not PART: return None

    TYPE = ogGetPartitionType (disk, par)
    if   'HNTFS'      == TYPE: NEWTYPE = 'NTFS'
    elif 'HFAT32'     == TYPE: NEWTYPE = 'FAT32'
    elif 'HFAT16'     == TYPE: NEWTYPE = 'FAT16'
    elif 'HFAT12'     == TYPE: NEWTYPE = 'FAT12'
    elif 'WIN-RESERV' == TYPE: NEWTYPE = 'WINDOWS'
    else:
        SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, TYPE)
        return None

    ogSetPartitionType (disk, par, NEWTYPE)


#/**
#         ogUnlockDisk int_ndisk
#@brief   Elimina el fichero de bloqueo para un disco.
#@param   int_ndisk      nº de orden del disco
#@return  (nada)
#@exception OG_ERR_FORMAT    Formato incorrecto.
#@exception OG_ERR_NOTFOUND  Disco o particion no corresponden con un dispositivo.
#@note    El fichero de bloqueo se localiza en \c /var/lock/disk, siendo \c disk el dispositivo del disco, sustituyendo el carácter "/" por "-".
#*/ ##
def ogUnlockDisk (disk):
    DISK = ogDiskToDev (disk)
    if not DISK: return None
    os.remove (f'/var/lock/lock{DISK.replace("/", "-")}')


#/**
#         ogUpdatePartitionTable
#@brief   Fuerza al kernel releer la tabla de particiones de los discos duros
#@param   no requiere
#@return  informacion propia de la herramienta
#@note    Requisitos: \c partprobe
#@warning pendiente estructurar la funcion a opengnsys
#*/ ##
def ogUpdatePartitionTable():
    for disk in ogDiskToDev():
        subprocess.run(["partprobe", disk])