TxF – NTFS Transaccional

Una capacidad de la que no se habla mucho es de TxF, que apareció junto con Vista: es la capacidad de tener transacciones sobre ficheros NTFS. Esas transacciones pueden afectar a uno o a varios ficheros… y no solo eso: gracias al poder de DTS podemos coordinar una transaccion TxF con otros tipos de transacciones como SQL Server o MSMQ!

Como pasa con muchas de las características avanzadas de windows, sólo se puede usar en .NET a través de p/invoke (si obviamos C++/CLI claro)… vamos a ver un ejemplo!

Primero creamos una clase que contenga todas las definiciones de los métodos Win32 que vamos a usar:

public static class NativeMethods
{
    public const uint GENERIC_READ = 0x80000000;
    public const uint GENERIC_WRITE = 0x40000000;
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern SafeFileHandle CreateFileTransacted(string lpFileName,
           uint dwDesiredAccess, uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,
           uint dwFlagsAndAttributes, IntPtr hTemplateFile, IntPtr hTransaction, IntPtr pusMiniVersion,
           IntPtr pExtendedParameter);

    [DllImport("ktmw32.dll", SetLastError = true)]
    public static extern IntPtr CreateTransaction(IntPtr lpTransactionAttributes, IntPtr uow,
        uint createOptions, uint isolationLevel, uint isolationFlags, uint timeout, string description);

    [DllImport("ktmw32.dll", SetLastError = true)]
    public static extern bool CommitTransaction(IntPtr transaction);

    [DllImport("ktmw32.dll", SetLastError = true)]
    public static extern bool RollbackTransaction(IntPtr transaction);

    [DllImport("Kernel32.dll")]
    public static extern bool CloseHandle(IntPtr handle);
}

Vamos a usar los siguientes métodos del api de Win32:

• CreateFileTransacted: Crea o abre un fichero para ser usado de forma transaccional. Una vez obtenido el handle, el resto de funciones win32 que trabajan con handles funcionan transaccionalmente con el nuevo handle.
• CreateTransaction: Crea la transaccion
• CommitTransaction: Hace el commit de la transaccion 
• RollbackTransaction: Hace el rollback de la transacción
• CloseHandle: Cierra un handle cualquiera (sea de fichero o no y sea transaccional o no).

Vamos a hacer un programilla que abra dos ficheros en modo transaccional, escriba algo en ellos y luego haga commit y/o rollback de la transacción para ver sus efectos…

Primero creamos la transacción y abrimos dos ficheros (suponemos que los nombres nos los pasarán por línea de comandos):

// 1. Crear la transacción
IntPtr transaction = NativeMethods.CreateTransaction(IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, null);
// 2. Abrir dos ficheros de forma transaccional
SafeFileHandle sfh1 = NativeMethods.CreateFileTransacted(args[0], NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE,
    0, IntPtr.Zero, (uint)FileMode.CreateNew, 0, IntPtr.Zero, transaction, IntPtr.Zero, IntPtr.Zero);
SafeFileHandle sfh2 = NativeMethods.CreateFileTransacted(args[1], NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE,
    0, IntPtr.Zero, (uint)FileMode.CreateNew, 0, IntPtr.Zero, transaction, IntPtr.Zero, IntPtr.Zero);

Una vez tenemos los handles cualquier función Win32 estándard para escribir o leer en ellos nos serviría… por suerte los file streams de .NET pueden ser creados a partir de un handle de Win32, así que podremos utilizar la clase FileStream.

Ahora ya sólo nos queda hacer un commit o un rollback… Para ello si se produce cualquier error durante la escritura haremos un rollback, y en caso contrario haremos un commit. Finalmente debemos cerrar la transacción y por ello usaremos CloseHandle.

El código es tal y como sigue:

try
{
    // Escribimos algo en ambos ficheros
    using (FileStream f1 = new FileStream(sfh1, FileAccess.ReadWrite))
    using (FileStream f2 = new FileStream(sfh2, FileAccess.ReadWrite))
    using (StreamWriter sw1 = new StreamWriter(f1))
    using (StreamWriter sw2 = new StreamWriter(f2))
    {
        sw1.Write("Fichero 1");
        if (args.Length > 2 && args[2] == "/e")
            throw new IOException("Error cualquiera");
        sw2.Write("Fichero 2");
    }

    // Lanzamos el commit. Si todo ha ido bien llegaremos aquí
    NativeMethods.CommitTransaction(transaction);
}
catch (IOException ex)
{
    // Algun error: lanzamos el rollback
    Console.WriteLine("Error en el acceso a ficheros:" + ex.Message);
    NativeMethods.RollbackTransaction(transaction);
}
finally
{
    // Cerramos la transacción TxF
    NativeMethods.CloseHandle(transaction);
}

Como se puede observar la escritura en los ficheros se hace a través de las clases estándard de .NET. Es solo la apertura del fichero que debe hacerse a través de la API de Win32, así como la creación de la transacción.

Si el tercer parámetro que se le pasa al programa es /e el programa simulará un error.

Si ejecutais el programa TxFDemo.exe f1.txt f2.txt vereis que os aparecen los dos ficheros.

Por otro lado si ejecutais TxFDemo f1.txt f2.txt /e vereis que NO os aparece ninguno de los dos ficheros, ya que se lanza la excepción y con ella se hace un rollback de la transacción NTFS.

Ahora imaginad las posibilidades que este sistema ofrece!

Eso sí recordad que es para Windows Vista o superior…

Link: Un artículo sobre TxF bastante interesante de Jason Olson.

Saludos!