Agrégation de messages et assemblage de fichier plat avec Windows Task Scheduler

Ugur AGACSEVEN
Publié par Ugur
Catégorie : BizTalk
20/07/2020

Introduction

Dans le cadre des projets BizTalk, un problématique que je rencontre souvent, est l’agrégation et l’assemblage de fichiers plats. Bien qu’il existe des dispositifs pour réaliser ces deux opérations, le plus important reste à savoir quand et comment clôturer l’agrégation.

Il est vrai que l’usage d’une orchestration est de mise dans notre situation et elle nous permet de gérer le temps imparti pour chaque agrégation. Pour plus d’infos, voir l’article suivant : Agréger des messages dans une orchestration avec un pipeline d’envoi.

Cependant si on veut planifier l’arrêt de l’agrégation selon certains jours de la semaine et heures de la journée, il faut aussi utiliser les fonctionnalités de planification offertes par les ports de réception. Et cela reste peu pratique lorsque l’on doit modifier le délai et l’occurence puisqu’il faut le faire à deux endroits différents.

C’est pourquoi, afin de centraliser le planificateur, je vais vous proposer une solution alternative via le planificateur de tâches Windows.

 

Architecture

Ci-dessous un schéma décrivant le déroulement du processus :

Processus d'agrégation de messages et d'assemblage de fichier plat

Avant tout, nous avons besoin d’un Pipeline contenant un Flat File Assembler, ce pipeline sera utilisé pour l’agrégation des messages sous forme d’un fichier plat en sortie.

Assembleur de fichier plat

Côté BizTalk, dans l’optique d’avoir un flux simple, nous allons utiliser l’exemple de la gestion de messages de type “Véhicule”. Et à cette fin, il est nécessaire d’avoir a minima ces quatre ports :

Les receive locations

  • Vehicle.ReceiveLocation, pour la réception des fichiers d’entrée ;
  • Vehicle.AggregatedVehicles.Scheduler, qui intercepte les fichiers après l’éxecution du script déclenché par le planificateur.

Les send ports

  • Vehicles.AfterAggregation, pour l’envoi des fichiers plats agrégés ;
  • Vehicles.Aggregation, qui, d’une part, transforme nos messages grâce au pipeline FlatFileAssembling_SendPipeline précédemment créé et qui, d’autre part, les ajoute au fichier plat temporaire via la fonction “Append” du FILE Transport Adapter .

Sélection du send pipeline Sélection du mode Append pour la copy

 

Grâce au planificateur de tâche (Windows Task Scheduler), nous déclenchons un script de changement d’extension qui va renommer le fichier temporaire dans lequel les messages ont été agrégés. Ainsi, l’astuce consiste à jouer avec les masques des noms de fichier. Concrètement, dès que le nom se termine par .csv et non plus par .tmp, alors cela signifie que l’agrégation est finie et de ce fait, que le fichier est prêt à être traité.

Création du task scheduler

Ajout du script au Scheduler Choix de la planification

À cet effet, voici notre script de changement d’extensions :

namespace AggregatedFileTMPToCSV {
    class Program {
        static void Main(string[] args) {
            // Premier paramètre : le chemin d'accès
            var directory = args[0];
            // Second paramètre : Le nom du fichier temporaire
            var filename = args[1];
            // Test de l'existence du fichier 
            if (File.Exists(Path.Combine(directory, filename))) {
                try {   
                    // Récupération du fichier en cours d'agrégation
                    var file = Directory.GetFiles(directory, filename).First();
                    // Changement d'extension
                    var newFileName = Path.ChangeExtension(file, ".csv");
                    // Remplacement du fichier 
                    File.Move(file, newFileName);
                } catch (Exception ex)
                {   throw ex;  }
            }
        }
    }
}

 

Exemple

Une fois que tout est mis en place, on peut désormais faire un test avec les six fichiers suivants, représentants différents messages véhicule :

Échantillons de messages véhicules

Avec BlackMotorBike.xml, tel que :

<ns0:Vehicle xmlns:ns0="http://MiddleWay.Blogs.Biztalk.FlatFileAssemblingAfterAggregation.Vehicles.Vehicle_Schema">
  <ns0:id>2</ns0:id>
  <ns0:type>Motorbike</ns0:type>
  <ns0:color>Black</ns0:color>
  <ns0:numberOfSeats>1</ns0:numberOfSeats>
  <ns0:numberOfWheels>2</ns0:numberOfWheels>
</ns0:Vehicle>

Après le déclenchement de notre flux, le fichier temporaire est créé :

Message en cours d'agrégation

Lorsque le planificateur active le script, le nom du fichier est changé et contient effectivement les données de chaque véhicule :

Message de véhicules agrégés

2 Motorbike Black 1 2
3 Truck Blue 3 10
6 Truck Green 3 10
1 Car Red 5 4
5 Motorbike White 1 2
4 Car Yellow 5 4

 

Pour aller plus loin…

Par ailleurs, sur l’un de mes projets, il m’a fallu séparer l’agrégation des messages selon la valeur d’un champ donné. En ce sens, reprenons l’exemple précédent et on promeut le champ souhaité, ici on va utiliser “type“.

Promotion du champs type

On greffe nos nouveaux ports d’envoi comportant un filtre sur le type, afin de récupérer uniquement les bons véhicules.

Les nouveaux send ports

Filtrage sur le type promu

Enfin, si on veut traiter séparément chaque type de véhicules, on peut réutiliser notre script sans le modifier, en conséquence, il suffit de planifier de nouvelles tâches pour chaqu’un d’entre eux.

Ajout des nouveaux scheduler

Résultats

Avant le déclenchement de notre planificateur, on observe, en effet, nos différents fichiers en cours d’agrégations.

Les différents type de véhicules en cours d'agrégation

Suite au passage de notre script, nos fichiers plats sont finalement prêts à l’envoi.

Différents messages agrégés selon leur type

Avec par exemple, […]_AgregatedCars.csv, qui renferme uniquement les données de type Motorbike :

1 Car Red 5 4
4 Car Yellow 5 4