joe di castro

Productividad & Linux: Ncdu

2012-10-19T22:40:00+02:00

Esta es una pequeña aplicación que sigue la máxima de Doug Mcllroy que acabaría resumiendo la filosofía Unix "Escribe programas que hagan una sola cosa y que la hagan bien". Y siguiendo la línea de los programas que engloban esta serie de productividad sobre Linux, es un programa de consola que se maneja íntegramente con el teclado, y donde además los atajos están inspirados en los de Vim.

Ncdu

Ncdu es un acrónimo para "NCurses Disk Usage", es decir, "Uso de disco con interfaz ncurses". Lo que pretendía Yoran Heling, su autor, cuando creo ncdu, era obtener un analizador de uso de disco en consola que fuera lo suficientemente ligero para poder emplearlo en un servidor remoto a través de ssh. El gran acierto fue emplear la interfaz ncurses para poder navegar por los directorios con extrema facilidad al mismo tiempo que se presentaba la información en un formato legible y amigable. El segundo y no menos importante acierto, es emplear los conocidos atajos de teclado de Vim para navegar entre los directorios.

El resultado es un analizador de ocupación de disco que es realmente útil, agradable de utilizar y que es tan rápido y ligero que se puede emplear sin interfaz gráfica y en maquinas remotas. Es una gran ayuda para los administradores de sistemas, que hasta ahora nos teníamos que pelear con otras herramientas bastante menos agradables. Es la típica herramienta que cuando la utilizas por primera vez piensas ¿Por qué demonios no la habría encontrado antes?

Como se puede ver la interfaz es muy limpia y carece de elementos superfluos que nos distraigan de lo importante, un pecado que cometen algunas de las aplicaciones gráficas más famosas, que cuentan con unos gráficos muy bonitos, pero realmente no demasiado útiles. Es sencillisima de emplear una vez que conoces los atajos y cuenta con ayuda integrada a la que se accede pulsando ?. Incluso para aquellos que no están acostumbrados a navegar empleando las típicas teclas de vim (h, j, k, l), se pueden utilizar las teclas de dirección.

Características

Un programa de este tipo no necesita una funcionalidad muy elevada, pero destacare aquí algunas de las posibilidades que nos ofrece:

Podemos ordenar los directorios/ficheros en función de su nombre o de su tamaño y en orden ascendente o descendente
Se pueden eliminar directamente ficheros o directorios desde la aplicación, aunque también podemos iniciarla en modo solo lectura para prevenir borrados accidentales
Se muestra o no, el porcentaje de espacio ocupado de forma gráfica y/o numérica
El espacio empleado en disco puede hacer referencia al real o al aparente
Los directorios y ficheros ocultos pueden ser o no mostrados
Nos permite recalcular el espacio ocupado de un directorio concreto sin necesidad de volver a recalcular todo
Tenemos la posibilidad de volcar la información a un archivo, que puede también ser leído por el mismo programa
Es posible mostrar la información de un elemento individual en un cuadro emergente

La verdad es que lo único que hecho en falta en el programa es quizás un poco de color para distinguir entre ficheros y directorios de forma más visual. Por lo demás, es muy rápido calculando el espacio, no he hecho una comparación directa, pero me parece ligeramente más rápido que Baobab.

Alternativas

Existen varias alternativas decentes como aplicaciones gráficas, como los conocidos Baobab (que viene con las herramientas de Gnome) o JDiskReport. Después existen múltiples alternativas tanto en modo gráfico como en modo consola que, sinceramente, no puedo recomendar a nadie, bien porque son más vistosos que prácticos o bien porque son directamente insufribles. Existe una alternativa en modo texto que algunos prefieren a ncdu que es gt5.

Monitorizar los cambios de tamaño en un directorio

2011-05-17T21:52:00+02:00

Cuando administramos varias maquinas UN*X nos puede interesar el tener controlados los cambios de tamaño en algunos directorios determinados, para poder observar pautas de comportamiento o ver cambios inesperados, para solucionar los problemas cuando o antes de que se produzcan. Y aunque hay varias formas de realizar esto, incluso con demonios que monitorizan los cambios en tiempo real (incrond, inotify, dnotify, gamin, watch, ...), puede que una solución más sencilla nos sea suficiente para directorios no críticos. Para instalaciones no complejas nos puede servir, por ejemplo, para no tener que lidiar con las quotas de disco (no siempre es una buena opción). O para evitar que por ejemplo una mala configuración en la rotación de los logs de una maquina acaben agotando el espacio disponible para la partición de sistema (caso real que me he encontrado más de una vez).

Para poder monitorizar los cambios de tamaño de un directorio (y subdirectorios) he creado un sencillo script Python que registra los cambios en la ruta que le proporcionemos y luego envía un informe por correo al buzón del usuario local. Los datos de los directorios los registra en un fichero oculto (su nombre empieza por un .) binario de tipo pickle y el informe se guarda a su vez en un archivo de texto con el mismo nombre que el script, pero terminado en .log.

El informe que genera nos muestra por un lado tantos los nuevos directorios, como los directorios que se han eliminado con la cifra del espacio en disco que ocupan (o liberan). Por otro lado también nos informa de los directorios que han cambiado de tamaño, mostrándonos en que porcentaje se han incrementado/decrementado y la cantidad de espacio que ha variado. Aquí podemos ver un ejemplo de uno de estos informes.

SCRIPT =========================================================================
dir_size_monitor (ver. 0.2)
http://joedicastro.com

Changes in size of directories for .. on yourmachine
================================================================================

START TIME =====================================================================
                                                      Tuesday 05/17/11, 21:10:48
================================================================================

NEW DIRECTORIES ________________________________________________________________

   799.72 KiB   ./src/test/bibendum
     1.14 MiB   ./src/test/condimentum
     2.31 MiB   ./src/test/laoreet
   204.28 KiB   ./src/test/risus
     2.90 MiB   ./src/test/torquent

DELETED DIRECTORIES ____________________________________________________________

   383.79 KiB   ./src/test/adipiscing
     5.38 MiB   ./src/test/consequat
   847.72 KiB   ./src/test/etiam
   938.93 KiB   ./src/test/maecenas
     3.55 MiB   ./src/test/tincidunt
     2.33 MiB   ./src/test/viverra

CHANGED DIRECTORIES ____________________________________________________________

    34.79 %     55.5 MiB   ./src
    34.82 %     55.5 MiB   ./src/test
   -99.97 %     15.3 MiB   ./src/test/odio
   -99.97 %     15.6 MiB   ./src/test/tellus

THRESHOLD VALUES _______________________________________________________________

The directories whose size differences are less than any of these values are ignored:

Percentage:     10 %
Size:        10.00 MiB

.. STATISTICS __________________________________________________________________

      78 directories
  215.04 MiB

END TIME =======================================================================
                                                      Tuesday 05/17/11, 21:10:48
================================================================================

Opcionalmente podemos establecer dos valores de umbral para que se ignoren todos los cambios que estén por debajo de estas dos cifras. Para desactivarlos simplemente hay que dejarlos a cero. Estas cifras se refieren por un lado al porcentaje de diferencia mínimo que deseamos establecer para que se nos informe y por otro a la cantidad mínima (expresada en bytes) de espacio en disco que se ha incrementado/decrementado en ese directorio. Pueden funcionar los dos a la vez, por lo que se han de cumplir las dos condiciones, o solamente uno dejando el otro a cero.

Si programamos este script para que se ejecute cada cierto tiempo, podemos tener una idea aproximada de los cambios producidos en el. Y digo aproximada porque este nos muestra únicamente los cambios registrados entre dos instantáneas tomadas, una en la ejecución anterior y otra en la ejecución actual. Y por lo tanto no esperemos obtener la relación de todos los cambios producidas entre ellas. Para conocer algo a ese nivel de detalle es mejor emplear uno de los servicios en tiempo real que mencionaba al principio. Dicho esto, es evidente que en la primera ejecución no tiene sentido informar de nada y de hecho hasta la segunda ejecución no empezara a generar informes.

Este es el contenido de dir_size_monitor.py es el siguiente:

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    dir_size_monitor.py: Monitors changes in the size of dirs for a given path
"""

#===============================================================================
# This Script monitors the changes in disk size for the directories included in
# a given path. It reports what directories are new or deleted. Also reports the
# directories in which their size increases or decreases above threshold values.
# These threshold values refer to the amount in difference of size of the 
# directory or/and the percentage difference. These values can be overrided by 
# setting them to zero.
#
# The final report is sended via email to the local user. This script is 
# intended to run periodically (e.g. via cron) 
#===============================================================================

#===============================================================================
#    Copyright 2011 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#===============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "17/05/2011"
__version__ = "0.2"

try:
    import sys
    import os
    import platform
    import pickle
    import logger
    from get_size import best_unit_size, get_size_fast
except ImportError:
    # Checks the installation of the necessary python modules 
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)

def list4log(dirs_size_dict, wpath, dirs):
    """Create a list of new or deleted directories for the log."""
    llst = []
    for ldir in sorted(dirs):
        dsz = best_unit_size(dirs_size_dict[ldir])
        llst.append(" {0:8.2f} {1}   ./{2}".
                    format(dsz['s'], dsz['u'], os.path.relpath(ldir, wpath)))
    return llst

def diff4log(before, current, wpath, dirs, threshold_pct=0, threshold_sz=0):
    """Create a list of the directories that had size changes for the log."""
    llst = []
    for ddir in sorted(dirs):
        pct = (((current[ddir] - float(before[ddir])) / before[ddir]) * 100.0)
        diff = current[ddir] - before[ddir]
        if abs(pct) >= threshold_pct and abs(diff) > threshold_sz:
            dsz = best_unit_size(diff)
            llst.append(" {0:8.2f} % {1:8.1f} {2}   ./{3}".
                        format(pct, dsz['s'], dsz['u'], os.path.relpath(ddir,
                                                                        wpath)))
    return llst

def main(first_exec=False):
    """Main section"""
    # The path to monitor changes in directories dir_size
    mon_pth = "/your/path/to/monitor"

    # Ignore all directories that are below these percentage or absolute value 
    # of size difference. There are optional, set to zero to override them.
    thld_pct = 20      # In percentage of difference in size for a directory
    thld_sz = 10.486E6 # In bytes of absolute value of directory size difference

    # Prepare the log
    log = logger.Logger()
    url = "http://joedicastro.com"
    head = ("Changes in size of directories for {0} on {1}".
            format(mon_pth, platform.node()))
    log.header(url, head)
    log.time("START TIME")

    # Load the last dictionary of directories/sizes if exists
    try:
        with open('.dir_sizes.pkl', 'rb') as input_file:
            bfr_dir = pickle.load(input_file)
    except (EOFError, IOError, pickle.PickleError):
        bfr_dir = {}
        first_exec = True

    # Get the current dictionary of directories/sizes
    crr_dir = {}
    for path, dirs, files in os.walk(mon_pth):
        for directory in dirs:
            dir_path = os.path.join(path, directory)
            dir_size = get_size_fast(dir_path)
            crr_dir[dir_path] = dir_size

    # First, Save the current dirs/sizes
    with open(".dir_sizes.pkl", "wb") as output_file:
        pickle.dump(crr_dir, output_file)

    # Create the list depending the status of directories
    deleted = [d for d in bfr_dir if d not in crr_dir]
    added = [d for d in crr_dir if d not in bfr_dir]
    changed = [d for d in crr_dir if d in bfr_dir if crr_dir[d] != bfr_dir[d]]

    log.list("Deleted directories", list4log(bfr_dir, mon_pth, deleted))
    log.list("New directories", list4log(crr_dir, mon_pth, added))
    log.list("Changed directories", diff4log(bfr_dir, crr_dir, mon_pth, changed,
                                             thld_pct, thld_sz))

    # If thresholds are nonzero, then report the values 
    if thld_pct or thld_sz:
        tsz = best_unit_size(thld_sz)
        log.list("Threshold Values",
                 ["The directories whose size differences are less than any of "
                  "these values are ignored:", "",
                  "Percentage: {0:6} %".format(thld_pct),
                  "Size:       {0:6.2f} {1}".format(tsz['s'], tsz['u'])])

    # Show some statistics for the analyzed path
    mon_pth_sz = best_unit_size(get_size_fast(mon_pth))
    log.list("{0} Statistics".format(mon_pth),
             ["{0:8} directories".format(len(crr_dir)),
              "{0:8.2f} {1}".format(mon_pth_sz['s'], mon_pth_sz['u'])])
    log.time("END TIME")
    if not first_exec:
        log.send("Changes in size of directories")
        log.write()

if __name__ == "__main__":
    main()

Este script necesita los módulos get_size y logger para poder funcionar. Solo es necesario descargar los archivos y guardarlos en el mismo directorio donde se aloje este script. La versión más actualizada de este script se puede encontrar en el repositorio Python Recipes alojado en github.

Conocer el tamaño de un directorio con Python

2011-05-16T21:05:00+02:00

Aunque conocer el tamaño de un directorio en sistemas como Linux es algo trivial, solo es necesario emplear el comando du, si queremos hacer lo mismo con Python -sin hacer uso de este comando- la cosa ya no es tan sencilla. Sobre todo si lo que queremos es una solución que nos devuelva tanto el tamaño de un fichero como el de un directorio. Cuando me encontré con esta necesidad lo primero que hice fue buscar en Internet para conocer alguna solución previa (reinventar la rueda no siempre es lo mejor) y me encontré con esto:

def get_dir_size(the_path):
    """Get size of a directory tree in bytes."""
    path_size = 0
    for path, dirs, files in os.walk(the_path):
        for fil in files:
            filename = os.path.join(path, fil)
            path_size += os.path.getsize(filename)
    return path_size

Esta solución nos daría el tamaño en bytes de un directorio. Pero esta solución, que encontré en varios sitios, presentaba dos problemas:

No da un tamaño exacto. Esto se debe a que no tiene en cuenta las carpetas y ficheros ocultos (los que empiezan con un . en Linux) y los ficheros especiales .. (que apuntan al directorio superior). Además tampoco tiene en cuenta los enlaces simbólicos. Por está razón la salida de esta función no coincide con el espacio que nos reporta el comando UN*X du -bs
No funciona para un solo fichero. Solo trabaja cuando lo ejecutamos sobre un directorio, al hacerlo sobre un solo fichero nos dará como resultado siempre 0.

Teniendo en cuenta este punto de partida, elaboré una función que solucionara estos dos problemas y que devolviera el tamaño exacto de un directorio o fichero. Esta es la función que nos da el resultado correcto:

def get_size(the_path):
    """Get size of a directory tree or a file in bytes."""
    path_size = 0
    for path, directories, files in os.walk(the_path):
        for filename in files:
            path_size += os.lstat(os.path.join(path, filename)).st_size
        for directory in directories:
            path_size += os.lstat(os.path.join(path, directory)).st_size
    path_size += os.path.getsize(the_path)
    return path_size

El resultado de esta función es el mismo que el que nos devuelve el comando Linux du -bs. Además tiene en cuenta los enlaces simbólicos y no los sigue. Luego buscando una solución ligeramente más rápida (aunque menos elegante y pythonica) y que siguiera dando resultados precisos, cree una variante basada en el empleo de generadores.

def get_size_fast(the_path):
    """Get size of a directory tree or a file in bytes."""

    def get_sizes(the_path):
        """Make a generator of individual file & directory sizes."""
        if not os.path.islink(the_path):
            if os.path.isdir(the_path):
                for file_or_dir in os.listdir(the_path):
                    path = os.path.join(the_path, file_or_dir)
                    if os.path.isfile(path):
                        yield os.lstat(path).st_size
                    else:
                        for size in get_sizes(path):
                            yield size
            yield os.lstat(the_path).st_size
        else:
            yield os.lstat(the_path).st_size

    return sum(get_sizes(the_path))

Obtener el tamaño del directorio en la mejor unidad posible

Estas funciones proporcionan el resultado que deseamos, pero lo entregan en una unidad difícilmente legible, en bytes. ¿Que ocurre si queremos verlo en Mebibytes, GibiBytes, ... y que además sea siempre la más adecuada para una mejor visualización? Para responder a esta pregunta desarrolle una función que nos hace precisamente esto, tomar un tamaño en bytes y devolvernos el valor correcto en la unidad binaria IEC más adecuada:

def best_unit_size(bytes_size):
    """Get a size in bytes & convert it to the best IEC prefix for readability.

    Return a dictionary with three pair of keys/values:

    "s" -- (float) Size of path converted to the best unit for easy read
    "u" -- (str) The prefix (IEC) for s (from bytes(2^0) to YiB(2^80))
    "b" -- (int / long) The original size in bytes

    """
    for exp in range(0, 90 , 10):
        bu_size = abs(bytes_size) / pow(2.0, exp)
        if int(bu_size) < 2 ** 10:
            unit = {0:"bytes", 10:"KiB", 20:"MiB", 30:"GiB", 40:"TiB", 50:"PiB",
                    60:"EiB", 70:"ZiB", 80:"YiB"}[exp]
            break
    return {"s":bu_size, "u":unit, "b":bytes_size}

Esta función nos devuelve un diccionario con tres claves:

's': Es el tamaño convertido a la mejor unidad IEC posible en términos de legibilidad.
'u': Es el prefijo IEC para el tamaño anterior.
'b': Es el tamaño original en bytes.

Para entenderla, lo mejor es mostrar algunos ejemplos:

>>> import get_size
>>> size = get_size.best_unit_size(38467206502)
>>> "{0:.2f} {1}".format(size['s'], size['u'])
'35.83 GiB'
>>> size = get_size.best_unit_size(45332)
>>> "{0:.2f} {1}".format(size['s'], size['u'])
'44.27 KiB'
>>> size = get_size.best_unit_size(9878323)
>>> "{0:.2f} {1} es igual a {2} bytes".format(size['s'], size['u'], size['b'])
'9.42 MiB es igual a 9878323 bytes'

Y evidentemente, combinar las dos funciones en una, nos evita tener que pasar las dos a un mismo directorio/fichero.

def get_unit_size(the_path):
    """Calculate size of a directory/file & convert it for the best IEC prefix.

    Return a dictionary with three pair of keys/values:

    "s" -- (float) Size of path converted to the best unit for easy read
    "u" -- (str) The prefix (IEC) for s (from bytes(2^0) to YiB(2^80))
    "b" -- (int / long) The original size in bytes

    """

    bytes_size = 0
    for path, directories, files in os.walk(the_path):
        for filename in files:
            bytes_size += os.lstat(os.path.join(path, filename)).st_size
        for directory in directories:
            bytes_size += os.lstat(os.path.join(path, directory)).st_size
    bytes_size += os.path.getsize(the_path)

    for exp in range(0, 90 , 10):
        bu_size = abs(bytes_size) / pow(2.0, exp)
        if int(bu_size) < 2 ** 10:
            unit = {0:"bytes", 10:"KiB", 20:"MiB", 30:"GiB", 40:"TiB", 50:"PiB",
                    60:"EiB", 70:"ZiB", 80:"YiB"}[exp]
            break
    return {"s":bu_size, "u":unit, "b":bytes_size}

Que nos devuelve un diccionario similar al anterior, lo que nos proporciona la posibilidad de disponer tanto del tamaño en bytes como en la mejor unidad IEC posible con una única función.

Todas estas funciones con ejemplos (y además una clase que hace uso de ellas), se pueden encontrar en el fichero get_size.py en mi repositorio Python Recipes que se encuentra alojado en github. Si se ejecuta el fichero como un script puede verse una comparativa de las diversas funciones en rendimiento y precisión con respecto al comando du -bs