joe di castro

Fabric & Rsync para realizar Backups

2011-07-13T20:21:00+02:00

En el anterior articulo empleaba fabric y rsync para sincronizar un directorio local y uno remoto en ambas direcciones. Además le añadía las funcionalidades de logger y notify para proporcionar información sobre el proceso durante y después de su ejecución. Y comenzaba el articulo recordando a lftp-mirror, el script que había creado para realizar la sincronización a través de FTP. Pero lftp-mirror realiza algo más que la sincronización, pues también permite realizar el archivado del directorio local en ficheros comprimidos y lanzar varias tareas en una sola ejecución.

Ahora he añadido esta funcionalidad al fichero fabric creado anteriormente. Así empleando este fichero podemos realizar el Backup periódico de varios servidores en una sola operación y de forma completamente automática (basta con programar su ejecución). Se sincronizan los dos directorios y se crea un archivo comprimido del directorio local por cada día de la semana. De este modo siempre tenemos una copia del estado del directorio remoto de los últimos siete días. Y al final del proceso en nuestro correo, un email con el informe del resultado por cada una de las tareas ejecutadas.

En este fichero, rsync_fabric.py, disponemos de tres posibles tareas:

$ fab -l

     A Fabric file for sync two directories (remote ⇄ local) with rsync.

Available commands:

    backup  Sync from remote to local & archive the local directory.
    down    Sync from remote to local.
    up      Sync from local to remote.

Con la primera realizamos el backup (sincronización + archivado) y con las siguientes solo la sincronización desde o hacia el servidor. Una de las ventajas de fabric es que nos permite concatenar tareas fácilmente desde la línea de comandos, así podemos lanzar varias sincronizaciones de forma simultanea. Para poder realizar esto, creo una configuración de sincronización por defecto y después creo una función para cada una las tareas adicionales que simplemente redefinen los valores de estas variables globales. Por ejemplo:

# Variables globales de sincronización predefenidas
env.host_string = "username@example.com"
env.remote = "/my_directory"
env.local = "/home/my_user/backups/my_directory"

# Redefinimos estas variables para otra configuración de sincronización. Por 
# supuesto, pueden tratarse de servidores distintos.
def _databases():
    global env
    env.host_string = "username@example.com"
    env.remote = "/databases"
    env.local = "/home/my_user/backups/databases"

Veamos ejemplos de como podemos utilizar estas tareas:

# "Si queremos sincronizar el contenido local hacia el remoto, por ejemplo 
# para subir los ficheros al servidor por primera vez. Empleando los valores 
# por defecto. El modificador -w lo empleo para que no se detenga en los 
# errores, que de ocurrir, los veremos luego en el informe final."
$ fab -w up
[localhost] local: rsync -pthrvz --delete /home/my_user/backups/my_directory/ 
 username@example.com:my_directory

Done.
# "Pero también podemos especificar una tarea distinta a la por defecto de 
# este modo. Sincronizando desde el servidor a nuestro directorio local las 
# bases de datos."
$ fab -w down:databases
[localhost] local: rsync -pthrvz --delete username@example.com:databases/ 
/home/my_user/backups/databases

Done.
# "Y por supuesto, podemos realizar varias tareas a la vez."
$  fab -w down backup:databases
[localhost] local: rsync -pthrvz --delete username@example.com:my_directory/ 
/home/my_user/backups/my_directory
[localhost] local: rsync -pthrvz --delete username@example.com:databases/ 
/home/my_user/backups/databases

Done.

No empleo contraseña alguna, ni en el fichero ni en la línea de comandos, podría hacerse perfectamente, pero prefiero emplear una clave RSA pública autorizada para las sesiones SSH en el servidor. Es bastante más seguro y cómodo. En los ejemplos no se ve la salida de rsync, pues es capturada (así como los erores) para ser mostrada a posteriori en los informes.

Un ejemplo de informe sería el siguiente:

START TIME =====================================================================
                                                    miércoles 13/07/11, 19:48:55
================================================================================

SCRIPT =========================================================================
fab (ver. Unknown)
Fabric Rsync
http://joedicastro.com

Syncing username@example.com:databases to /home/my_user/backups/databases
================================================================================

RSYNC OUTPUT ___________________________________________________________________

receiving file list ... done

sent 20 bytes  received 825 bytes  153.64 bytes/sec
total size is 827.76M  speedup is 979595.42

ROTATE COMPRESSED COPIES _______________________________________________________

Created file:

/home/my_user/backups/databases_13jul2011_19:49_mié.tar.gz

Deleted old file:

databases_13jul2011_19:37_mié.tar.gz

DISK SPACE USED ================================================================
                                                                        1.60 GiB
================================================================================

END TIME =======================================================================
                                                    miércoles 13/07/11, 19:50:02
================================================================================

Que como podemos ver, ha tardado poco más de un minuto en sincronizar 827.56 Megabytes y el total de espacio ocupado por el directorio y los siete archivos comprimidos es de 1.60 Gibibytes (1,72 Gigabytes).

Ventajas

Las ventajas de sincronizarlo con rsync + ssh vs ftp, como ya comenté en el anterior articulo son enormes. Se ahorra muchísimo tiempo y ancho de banda, lo que ayuda a no saturar la red y no tener que planificar con tanto cuidado las ventanas de backup. Por ejemplo he realizado unas pruebas y para las mismas condiciones: mismo servidor, mismo directorio, mismo horario y condiciones de red; la sincronización remoto → local a través de FTP emplea entre 35 y 45 minutos y cuando lo hacemos a través de rsync emplea entre 2 y 4 minutos. Ahí es nada, estamos hablando de un proceso ~13 veces más rápido.

Código

El código del fichero fabric es el siguiente:

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

import os
import glob
import tarfile
import time
from get_size import get_size as _get_size
from get_size import best_unit_size as _best_unit_size
from logger import Logger as _logger
from notify import notify as _notify
from fabric.api import env, local

LOG = _logger()

#===============================================================================
# RSYNC HOSTS
#===============================================================================

# Your default host. No need any more if only wants a host.
env.host_string = "username@host"
env.remote = "/your/remote/path"
env.local = "/your/local/path"

# If wants to use various hosts, then define the previous variables like this, 
# one function per host. 
def _host_1():
    """Host variables for host_1."""
    global env
    env.host_string = "username@host_1"
    env.remote = "/your/remote/path/in/host_1"
    env.local = "/your/local/path/for/host_1"

def _host_2():
    """Host variables for host_2."""
    global env
    env.host_string = "username@host_2"
    env.remote = "/your/remote/path/in/host_2"
    env.local = "/your/local/path/for/host_2"

# ...
#
# def _host_n():
#     """Host variables for host_n."""
#     global env
#     env.host_string = "username@host_n"
#     env.remote = "/your/remote/path/in/host_n"
#     env.local = "/your/local/path/for/host_n"

#===============================================================================
# END RSYNC HOSTS
#===============================================================================

def _log_start():
    """Create the Start time info block for the log."""
    # Init the log for multiple hosts. Do not repeat the previous logs.
    if LOG.get():
        LOG.__init__()
    LOG.time("Start time")

def _log_end(task):
    """Create the End time info block and send & write the log."""
    _notify("Rsync", "Ended" , "ok")
    LOG.time("End time")
    LOG.free(os.linesep * 2)
    LOG.write(True)
    LOG.send("Fabric Rsync ({0})".format(task))

def _check_local():
    """Create local directory if no exists."""
    if not os.path.exists(env.local):
        os.mkdir(env.local)

def _rsync(source, target, delete):
    """Process the _rsync command."""
    _log_start()
    LOG.header("Fabric Rsync\nhttp://joedicastro.com",
               "Syncing {0} to {1}".format(source, target))
    _notify("Rsync", "Start syncing {0} to {1}".format(source, target), "info")
    out = local("rsync -pthrvz {2} {0}/ {1}".
                format(source, target, "--delete" if delete == "yes" else ""),
                capture=True)
    _notify("Rsync", "Finished synchronization", "ok")
    LOG.list("Rsync Output", out)
    if out.failed:
        LOG.list("Rsync Errors", out.stderr)

def _compress(path):
    """Compress a local directory into a gz file.

    Creates a file for each weekday, an removes the old files if exists"""
    os.chdir(os.path.join(path, os.pardir))
    dir2gz = os.path.basename(path)
    old_gzs = glob.glob('{0}*{1}.tar.gz'.format(dir2gz, time.strftime('%a')))
    gz_name = "{0}_{1}.tar.gz".format(dir2gz, time.strftime('%d%b%Y_%H:%M_%a'))
    gz_file = tarfile.open(gz_name, "w:gz")
    gz_file.add(path, arcname=dir2gz)
    gz_file.close()
    output = os.linesep.join(['Created file:', '', os.path.join(os.getcwd(),
                                                                gz_name)])
    for old_gz in old_gzs:
        os.remove(old_gz)
        output += os.linesep.join([os.linesep, 'Deleted old file:', '', old_gz])
    return output

def _archive():
    """Archive the local directory in a gz file for each weekday."""
    _notify('Rsync', 'Compressing folder...', 'info')
    LOG.list('Rotate compressed copies', _compress(env.local))
    _notify("Rsync", "Finished compression", "ok")

def _get_diskspace():
    """Get the disk space used by the local directory and archives."""
    gz_size = sum([_get_size(gz) for gz in glob.glob('{0}*.gz'.
                                                     format(env.local))])
    log_size = _get_size(LOG.filename) if os.path.exists(LOG.filename) else 0
    local_size = _get_size(env.local)
    size = _best_unit_size(local_size + gz_size + log_size)
    LOG.block('Disk space used', '{0:>76.2f} {1}'.format(size['s'], size['u']))

def up(server=None, dlt='yes'):
    """Sync from local to remote."""
    globals()["_" + server]() if server else None
    _rsync(env.local, ":".join([env.host_string, env.remote]), dlt)
    _log_end(server)

def down(server=None, dlt='yes', archive=False):
    """Sync from remote to local."""
    globals()["_" + server]() if server else None
    _check_local()
    _rsync(":".join([env.host_string, env.remote]), env.local, dlt)
    if not archive:
        _log_end(server)

def backup(server=None):
    """Sync from remote to local & archive the local directory."""
    down(server, archive=True)
    _archive()
    _get_diskspace()
    _log_end(server)

El fichero siempre actualizado puede ser encontrado en el repositorio Python Recipes que está alojado en github con el nombre rsync_fabfile.py

Sincronizar dos directorios con Fabric y Rsync

2011-07-06T22:02:00+02:00

Anteriormente habíamos visto como sincronizar un directorio remoto y uno local empleando solamente FTP. Ahora vamos a ver la forma de hacerlo empleando ssh y rsync. Para ello vamos a utilizar otra vez Python y una herramienta muy valiosa para cualquier sysadmin que se precie como es fabric (que descubrí gracias a Manuel Viera en esta pregunta en majibu). Evidentemente realizar la sincronización con rsync esta a años luz de hacerlo con FTP, la velocidad de sincronización, el tiempo empleado y la cantidad de datos a mover son mucho menores. FTP es algo que debería utilizarse únicamente cuando no disponemos de acceso via SSH.

La gran ventaja de fabric es que nos permite ahorrarnos el tener que implementar el acceso SSH con paramiko y la entrada de opciones y argumentos con argparse. Gracias a esto los scripts necesarios son mucho más cortos y limpios y su utilización es bastante más sencilla. Fabric ya incorpora una función para emplear rsync, rsync_project, dentro de su modulo de proyectos contribuidos fabric.contrib.project

Una forma de implementar esta sincronización en ambas direcciones empleando esta función predefinida sería esta:

from fabric.api import env, hosts, local
from fabric.contrib.project import rsync_project

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

@hosts(env.host_string)
def rsync_up(dlt="yes"):
    rsync_project(REMOTE_PATH, LOCAL_PATH + "/", 
                  delete= True if dlt == "yes" else False)

def rsync_down(dlt="yes"):
    local("rsync -pthrvz {0}:{1}/ {2} {3}".
          format(env.host_string, REMOTE_PATH, LOCAL_PATH, 
          "--delete" if dlt == "yes" else ""))

Y luego solo tendríamos que llamar a la función deseada:

# "Para sincronizar de remoto a local"
$ fab rsync_down

Hay que tener en cuenta un detalle con fabric. Cuando se le pasa un parámetro, este es siempre convertido a una cadena. Luego al pasarle True o False no se convierte en un valor booleano, sino una cadena "True"o "False". De ahí que compruebe si el parámetro coincide con "yes" en vez de un valor booleano.

El problema con la función rsync predefinida de fabric es que esta pensada únicamente para subir archivos a un servidor remoto, es decir, es una sincronización en una sola dirección, por eso implemento la sincronización en sentido contrario sin emplearla y empleando local. La autentificación de la sesión SSH puede realizarse especificando la contraseña dentro del propio fichero, pero va en contra del sentido común emplear un método tan inseguro como este. Lo lógico es emplear autorizaciones de sesiones SSH sin contraseña por medio de una clave pública.

Podríamos prescindir de la librería incorporada dentro de fabric y tendríamos algo como esto:

from fabric.api import env, local

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

def _rsync(source, target, delete):
    """Process the _rsync command."""
    output = local("rsync -pthrvz {0}/ {1} {2}".
                   format(source, target, "--delete" if delete == "yes" else ""))

def up(dlt='yes'):
    """Sync from local to remote."""
    _rsync(LOCAL_PATH, ":".join([env.host_string, REMOTE_PATH]), dlt)

def down(dlt='yes'):
    """Sync from remote to local."""
    _rsync(":".join([env.host_string, REMOTE_PATH]), LOCAL_PATH, dlt)

Pero... un momento, si estamos empleado un comando local, no empleamos rsync_project y empleamos una clave pública para el acceso SSH, entonces no estamos empleando paramiko, ¿de que nos sirve emplear fabric?. Bueno, en realidad rsync_project también emplea local, por lo que no emplea paramiko. Pero las ventajas vienen de que, por ejemplo, este mismo script se podría modificar fácilmente para ejecutar rsync en el servidor en vez de en nuestra maquina local, empleando run en vez de local. Además podemos emplear el mismo fichero para añadir varias tareas más a realizar en el servidor, aparte de la sincronización. Podríamos prescindir de fabric y hacer esto mismo con un script con un número similar de líneas, pero esto nos permite centralizar todas las tareas más comunes sobre ese servidor en un único fichero. Por ejemplo podríamos añadir una tarea para hacer un respaldo previo de una base de datos en el servidor, empleando un comando remoto en el servidor, luego hacer la sincronización separada de la BDD y el resto de ficheros y finalmente eliminar ese respaldo. Puede haber cientos de razones para preferir emplear fabric antes de un script independiente para la sincronización.

Ejecución desatendida de la sincronización

Si queremos programar esta tarea, no sería mala idea que nos avisara de cuando comienza a ejecutarse y del resultado de la misma. Para ello puedo emplear Logger y notify, para implementar esta funcionalidad.

from logger import Logger as _logger
from notify import notify as _notify
from fabric.api import env, local

env.host_string = "username@host"
REMOTE_PATH = "/your/remote/path"
LOCAL_PATH = "/your/local/path"

def _rsync(source, target, delete):
    """Process the _rsync command."""
    log = _logger()
    log.header("Fabric Rsync\nhttp://joedicastro.com",
               "Syncing {0} to {1}".format(source, target))
    log.time("Start time")
    _notify("Rsync", "Start syncing {0} to {1}".format(source, target), "info")
    output = local("rsync -pthrvz {0}/ {1} {2}".
                   format(source, target, "--delete" if delete == "yes" else ""),
                   capture=True)
    _notify("Rsync", "Finished", "ok")
    log.list("Output", output)
    if output.failed:
        log.list("Error", output.stderr)
    log.time("End time")
    log.send("Fabric Rsync")

def up(dlt='yes'):
    """Sync from local to remote."""
    _rsync(LOCAL_PATH, ":".join([env.host_string, REMOTE_PATH]), dlt)

def down(dlt='yes'):
    """Sync from remote to local."""
    _rsync(":".join([env.host_string, REMOTE_PATH]), LOCAL_PATH, dlt)

De esta forma, nos avisaría con una notificación en el escritorio de su inicio y fin, y al acabarse la sincronización, tendríamos un informe en nuestro correo parecido a este:

SCRIPT =========================================================================
fab (ver. Unknown)
Fabric Rsync

Syncing username@host:/your/remote/path to /your/local/path
================================================================================

START TIME =====================================================================
                                                   miércoles 06/07/11, 21:50:48
================================================================================

OUTPUT _________________________________________________________________________

receiving file list ... done
./
index.php

sent 48 bytes  received 200 bytes  45.09 bytes/sec
total size is 99  speedup is 0.40

END TIME =======================================================================
                                                   miércoles 06/07/11, 21:50:54
================================================================================

Este fichero está disponible en el repositorio Python Recipes alojado en github.

Sincronizar una carpeta local y una remota a través de FTP: lftp-mirror

2010-12-19T14:58:00+01:00

A veces tenemos la necesidad de subir (o bajar) contenido a un servidor y posteriormente tener actualizados los cambios que se produzcan en uno (o ambos) de los lados. Es decir tener sincronizados el directorio remoto y el local. Esto es relativamente fácil cuanto tenemos acceso via consola y ssh al servidor y podemos utilizar programas tan potentes como rsync. ¿Pero que ocurre cuando el único método del que disponemos para intercambiar ficheros con el servidor es a través del protocolo FTP, como ocurre con muchos servidores web?

Bien, en ese caso, tenemos un pequeño problema. El protocolo FTP aunque perfectamente valido para las funciones para las que fue originalmente creado, la transferencia de archivos, no contempla este caso. La solución manual y menos efectiva es volver a transferir todos los archivos cada vez que se produce un cambio, solución nada recomendable a nada que el tamaño de estos empiece a ser superior a decenas de Megabytes. También podríamos ir comprobando manualmente que ficheros han cambiado y transferir únicamente estos, algo también muy poco recomendable si el número de archivos es elevado. Afortunadamente algunos clientes gráficos de FTP nos permiten comprobar que ficheros son distintos en uno y otro lado y luego transferir únicamente estos, lo cual ya es un método bastante más efectivo y adecuado. Aunque si se trata de directorios con muchos archivos y una estructura jerárquica compleja (muchos directorios y subdirectorios) el proceso es bastante lento pues ha de ir comprobando en un lado y en el otro las diferencias entre los archivos (fecha, tamaño y atributos únicamente) recorriendolos todos. ¿Pero que ocurre si queremos realizar esta operación de forma periódica y automática? entonces esta solución tampoco es valida, pues necesitaríamos un programa de línea de comandos o un script para realizarlo.

Por suerte para nosotros, esta solución también está disponible a través de varios programas y scripts para consola, entre los cuales el mejor es lftp de Alexander V. Lukyanov. Este fantástico programa es una navaja suiza para todo aquello que necesitemos hacer a través de FTP, siendo uno de los mejores clientes FTP, si no el mejor, que existen. Y una de las innumerables posibilidades que ofrece es precisamente la de sincronizar dos directorios con la opción mirror (espejar). De esta manera podemos mantener perfectamente sincronizados dos directorios de forma automática. Nos permite hacer la sincronización en ambas direcciones, remoto → local y local → remoto.

Como ya he mencionado es muy potente y repleto de opciones y permite muchas más operaciones más allá de la sincronización entre directorios. Por este motivo he creado un script en Python que empleando lftp, se centra únicamente en la sincronización entre directorios a través de FTP y añade algunas nuevas funcionalidades, lftp-mirror.

¿Que ventajas aporta este script?

Proporciona un log detallado y legible que graba en un fichero en disco y que puede ser enviado por correo electrónico a una o varias direcciones empleando el servidor de correo local o uno externo.
Permite crear una copia comprimida por día de la semana del directorio local sincronizado. Esto nos permite tener el directorio actualizado y una copia de seguridad por cada uno de los últimos 7 días, para poder revertir algún cambio o borrado accidental.
Se centra únicamente en la sincronización (mirror) entre directorios, obviando las otras opciones que nos ofrece lftp
Nos proporciona (en el log) el tamaño del espacio ocupado en el disco duro por el directorio local y las copias de seguridad.
Permite tres modos de ejecución distintos, lo que lo convierte en muy versátil:
- Como tarea programada. En este modo los parámetros de la sincronización se incluyen directamente dentro del script y solo es necesario programar su ejecución para automatizar el proceso. Es ideal para la sincronización periódica de un único directorio/servidor FTP
- Interactivo. En este modo los parámetros se introducen directamente como argumentos en la línea de comandos. Es ideal para ejecutar una sincronización puntual manual
- Importando los parámetros desde un fichero de configuración. Este modo es similar al primero, con la diferencia de que en este caso los parámetros los tomamos de un fichero de configuración externo. Este fichero que podemos crear nosotros mismos (se sirve uno de ejemplo) nos permite establecer múltiples operaciones de sincronización que se ejecutaran de manera secuencial una detrás de otra.
En sistemas operativos que lo soporten nos muestra notificaciones emergentes a través de la librería libnotify de la ejecución del script y su correcta finalización. Por ejemplo, a través de las notificaciones emergentes de Ubuntu. Muy útil para conocer cuando se está ejecutando una tarea programada sin salida por consola.
Si empleamos los modos de ejecución no interactivos, emplea base64 para una mínima protección de la contraseñas de acceso a los servidores FTP y evitar almacenarlas las mismas en texto claro. No es una fuerte medida de seguridad, pero es lo mínimo que deberíamos tener en cuenta.

¿Para que nos puede servir este script?

Vamos a ver un ejemplo de lo más común, las copias de seguridad de una página web. En muchos hosting compartidos la única posibilidad de transferir archivos con el servidor es a través de una cuenta FTP. Empleando este script, podemos crear un directorio en local donde haremos las copias de seguridad de los ficheros de la web y luego sincronizarlo automáticamente todos los días, descargando únicamente los ficheros que han cambiado. Con esto tendremos no solo el directorio actualizado diariamente, si no que además dispondremos de una copia de seguridad por cada uno de los siete días anteriores para poder corregir cualquier problema ocurrido entre esas fechas. Configurar algo así es realmente sencillo, únicamente tendríamos que cambiar los valores incorporados dentro del script por los que necesitamos y luego programar su ejecución diaria con cron.

Para una introducción más detallada, instrucciones de ejecución, control de versiones y enlaces para la descarga, acudir al repositorio del script en github.

Un extracto del código de lftp-mirror.py:

def mirror(args, log):
    """Mirror the directories."""

    user = '' if args.anonymous else ' '.join(args.login)
    local, remote = os.path.normpath(args.local), os.path.normpath(args.remote)
    port = '-p {0}'.format(args.port) if args.port else ''
    include = ' --include-glob {0}'.format(args.inc_glob) if args.inc_glob else ''
    exclude = ' --exclude-glob {0}'.format(args.exc_glob) if args.exc_glob else ''

    url = 'http://joedicastro.com'
    msg = 'Connected to {1} as {2}{0}'.format(os.linesep, args.site, 'anonymous'
                                              if args.anonymous
                                              else args.login[0])
    msg += 'Mirror {0} to {1}'.format(local if args.reverse else remote,
                                      remote if args.reverse else local)
    log.header(url, msg)
    log.time('Start time')
    notify('Mirroring with {0}...'.format(args.site), 'sync')

    if not os.path.exists(local):
        os.mkdir(local)
        log.list('Created new directory', local)
    os.chdir(os.path.join(local, os.pardir))

    # create the script file to import with lftp
    scp_args = ('-vvv' + args.erase + args.newer + args.parallel + args.reverse
                + args.del_first + args.depth_first + args.no_empty_dir +
                args.no_recursion + args.dry_run + args.use_cache +
                args.del_source + args.missing + args.existing + args.loop +
                args.size + args.time + args.no_perms + args.no_umask +
                args.no_symlinks + args.suid + args.chown + args.dereference +
                exclude + include)

    with open('ftpscript', 'w') as script:
        lines = ('open {0}ftp://{1} {2}'.format(args.secure, args.site, port),
                 'user {0}'.format(user),
                 'mirror {0} {1} {2}'.format(scp_args,
                                             local if args.reverse else remote,
                                             remote if args.reverse else local),
                'exit')
        script.write(os.linesep.join(lines))

    # mirror
    cmd = ['lftp', '-d', '-f', script.name]
    sync = Popen(cmd, stdout=PIPE, stderr={True:STDOUT, False:None}[args.quiet])
    # end mirroring

    log.list('lftp output', ''.join(sync.stdout.readlines()))

    # compress the dir and create a .gz file with date
    if not args.reverse and not args.no_compress:
        notify('Compressing folder...', 'info')
        log.list('Rotate compressed copies', compress(local))
    # end compress

    gz_size = sum([get_size(gz) for gz in glob.glob('{0}*.gz'.format(local))])
    log_size = get_size(log.filename) if os.path.exists(log.filename) else 0
    local_size = get_size(local)
    size = best_unit_size(local_size + gz_size + log_size)
    log.block('Disk space used', '{0:>76.2f} {1}'.format(size['s'], size['u']))
    log.time('End Time')
    log.free(os.linesep * 2)
    log.write(True)

    os.remove(script.name)

Para obtener el código completo, ir al fichero fuente.