Les nouvelles API de Windows Vista et Windows Serveur 2008 : Kernel Transaction Manager et NTFS Transactionnel

  • Article

Auteur : Eric Vernié, responsable technique en charge des relations développeurs

Document de référence

Révision 1.0

 

Table des matières

IntroductionIntroduction

Rappel sur les transactionsRappel sur les transactions

Qu'est-ce qu'une transaction ?Qu'est-ce qu'une transaction ?

Qu'est-ce que Kernel Transaction Manager ?Qu'est-ce que Kernel Transaction Manager ?

  • NTFS Transactionnel TxF
  • Comment ça marche ?

ConclusionConclusion

Introduction

Après les deux premiers articles, consacrés aux API [Application Recovery & Restart](bb870268(v=msdn.10).md) et [Windows Error Reporting](https://msdn.microsoft.com/fr-fr/library/bb870262\(v=msdn.10\)), nous continuons notre saga sur la fiabilité et la robustesse, en explorant aujourd'hui une nouveauté du noyau de Windows Vista et Windows Serveur 2008 :

  • Kernel Transaction Manager, ainsi que du composant NTFS TransactionnelTxF qui en tire profit.

Technologies utilisées:

C/C++

MFC

Visual Studio 2008 Beta 2

(disponible en téléchargement ici : https://msdn2.microsoft.com/en-us/vstudio/aa700831.aspx)

Software development Kit Vista  : https://www.microsoft.com/downloads/details.aspx?familyid=FF6467E6-5BBA-4BF5-B562-9199BE864D29&mg_id=10114

Rappel sur les transactions

Une transaction est un concept qui simplifie la vie des développeurs d'application, car elle fournie un modèle simple en cas de d'erreur. En un mot, les transactions regroupent un certain nombre d'actions en une seule opération atomique. Soit toutes les opérations réussissent, soit toutes les opérations ne réussissent pas. Si une seule opération ne réussit pas dans un groupe ou toutes les autres opérations ont réussies, alors toutes les opérations doivent revenir à leur état initiale, on appel cela un rollback.

La notion de transaction n'est pas nouvelle, et est disponible depuis des lustres dans des systèmes de tels que les bases de données. Sur la plate-forme Microsoft ont trouvent des applications serveurs tels que SQL Serveur, des composants applicatifs tels que MSMQ, Exchange et MSDTC qui supportent les transactions locales ou distribuées.

Qu'est-ce qu'une transaction ?

Une transaction, c'est un groupe d'opérations, qui doit garantir les états suivants :

Atomique : Toutes les opérations réussissent ou aucune ne réussissent

Consistant : Si les données sont intègres avant le début de la transaction, alors elles doivent être intègres une fois la transaction achevée

Isolée : Toutes les transactions, sont isolées les unes des autres. Aucun effet de l'une ne pourra influer sur l'autre.

Durable : Lorsqu'une transaction est achevée, le résultat est persistant et survivra à un crash du système.

Qu'est-ce que Kernel Transaction Manager ?

Kernel Transaction Manager (KTM), est un gestionnaire de transaction au niveau noyau de Windows et permet à certain composant du système, tel que NTFS Transactionnel (TxF), ou le registre transactionnel (TxR) d'en tirer profit.

Le moteur de transaction peut à la fois opérer en mode "user" via MSDTC pour des transactions distribuées et en mode "kernel" comme indiqué sur la figure ci-dessous.

NTFS Transactionnel TxF.

Une application peut utiliser TxF, pour préserver l'intégrité de ses données sur disque lorsqu'une erreur exceptionnelle apparait.

Pourquoi utiliser des transactions sur des fichiers ?

Imaginez que pendant la mise à jour d'une application, un problème survient. Quelle catastrophe, si jamais plusieurs fichiers ne sont pas cohérents entre eux. L'application risque de ne plus fonctionner correctement. Avec Txf, ont simplifie le modèle de développement en permettant à l'application de valider tout un groupe d'opérations de copies par exemple, ou de revenir en arrière (rollback) sur tout le groupe de copies.

Imaginez par exemple, que vous souhaitiez renommer sur un site Web des fichiers et mettre à jour les liens qui y font références. Le faite d'intégrer dans une transaction ces deux opérations, vous garantie qu'il n'y aura pas d'inconsistance au cas où un plantage survient. Aucun lien ne fera référence à un ancien  nom de fichier. Soit le fichier est renommé et son lien associé mise à jour, soit aucun des deux n'est modifié.

Enfin, Txf isole les transactions concurrentes. Si une application ouvre un fichier dans une transaction pour lecture seulement, alors que dans le même temps une autre application à le même fichier ouvert pour une mise à jour toujours dans une transaction, TxF isole l'effet d'une transaction par rapport à l'autre. En d'autres termes la transaction qui lit le fichier, ne voit pas les modifications qui sont apportées par l'autre transaction.

Comment ça marche ?

Pour que le Kernel Transaction Manager puisse prendre en compte une transaction, on utilisera les 3 fonctions suivantes.

CreateTransaction(), pour créer une transaction

CommitTransaction(), pour valider la transaction

RollbackTransaction(), pour annuler la transaction

Ces fonctions sont définies dans l'entête Ktmw32.h et dans la librairie Ktmw32.lib

Ensuite si ont veut utiliser NTFS pour effectuer des transactions sur un fichier il suffit d'utiliser la fonction en corrélation avec les Transactions.

Par exemple, pour créer, copier, supprimer, déplacer un fichier, ont utilises traditionnellement les fonctions suivantes :

CreateFile(), CopyFile(), DeleteFile(), et MoveFile(). Désormais si vous souhaitez les intégrer dans une transaction, il suffira d'utiliser les fonctions idoines telles que :

CreateFileTransacted(), CopyFileTransacted(), DeleteFileTransacted (), et MoveFileTransacted ()

Ces fonctions ont un paramètre supplémentaire important, le handle de la transaction crée par la fonction CreateTransaction () de KTM.

Dans l'exemple suivant, je crée un fichier en mode transactionnel, et en fonction d'un paramètre je valide ou ne valide pas la transaction.

Bien évidement dans votre code, vous utiliseriez le mode transactionnel dans une gestion des exceptions plus appropriée.

  

    //Création du handle de transaction
    
HANDLE htransaction =CreateTransaction(NULL,0, 
     TRANSACTION_DO_NOT_PROMOTE,0,0,NULL,"Description de la Transaction");
     if (NULL==htransaction)
     {
          //Code omis pour plus de clarté
     }
//Création du fichier en mode transactionnel
     HANDLE hfile=CreateFileTransacted(L"TestTransaction.txt", GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,0,htransaction, 0,0);
     if (NULL==hfile)
     {
          //Code omis pour plus de clarté
     }
     //Récupère la saisie de l'utilisateur
     m_Edit.GetWindowTextW (cs);
     const wchar_t *buffer=cs.GetString ();
     DWORD pnumBytes;
     DWORD npb=cs.GetLength ()*2;
     //Ecrit dans le fichier. A noter que l'on utilise l'API Traditionnelle pour écrire
     BOOL b=WriteFile(hfile,buffer,npb,&pnumBytes,NULL);
     if (b==FALSE)
     {
          //Code omis pour plus de clarté
     }
//Si l'utilisateur à coché la case KTM valide la transaction
//et le fichier est crée avec ses données
if (m_checktransaction)
   b=CommitTransaction(htransaction); 
else //Sinon le fichier n'est pas crée
   b=RollbackTransaction(htransaction);

if (b==FALSE)
   {
          MessageBox(L"Ne peut valider la transaction",L"Test TxF",0);
     }
cleanup:
     if (hfile)
     {
          CloseHandle(hfile);
     }
       if (htransaction)
       {
          CloseHandle(htransaction);
       }
 }

Vous retrouverez dans le fichier zip associé à cet article la totalité du code qui permet de faire du transactionnel sur un fichier.

Conclusion

Dans ce 3ième article, nous démontrons une nouvelle fois qu'avec Windows Vista et Windows Serveur 2008 il est facile d'ajouter plus de robustesse à son application.

Quoi de plus simple que d'utiliser Kernel Transaction Manager et NTFS transactionnel (TxF) et fournir aux utilisateurs des applications encore plus fiables et plus robustes. Alors messieurs, à vos claviers.

Dans les prochains articles, nous continuerons notre saga sur la robustesse d'application avec Windows Vista et Windows Serveur 2008, en illustrant les API suivantes :