Manuel d'implémentation › Exemples d'étude de cas › Ecriture d'exemples de logique applicative efficaces › Etude de cas 16 : Modèles de conception de logique applicative

Etude de cas 16 : Modèles de conception de logique applicative

Il existe plusieurs "Modèles de conception" que vous pouvez utiliser dans un grand nombre de logiques applicatives. Ces modèles de conception sont testés, leur utilisation (lorsqu'elle est possible) peut faire gagner un temps précieux et la plupart du temps créer une logique applicative plus efficace. Cette étude de cas se concentre sur l'un de ces modèles de conception.

Mettre à jour les modèles de conception de compteurs

Ce modèle de conception conçu pour mesurer le temps entre certains événements est utile dans presque toutes les logiques applicatives. De telles logiques applicatives peuvent servir à mesurer le temps de disponibilité, le temps d'indisponibilité, la durée moyenne entre deux pannes, la durée moyenne nécessaire pour restaurer, le temps de réponse moyen, la durée moyenne de résolution, le pourcentage de composants ayant une disponibilité inférieure à X, le nombre de cas non résolus à temps, etc.

Le point commun à toutes ces logiques applicatives est que leur résultat dépend de l'horodatage des divers événements qu'elles reçoivent.

Un principe de base pour décider si votre logique applicative peut bénéficier de ce modèle de conception serait : si votre logique applicative dépend de l'horodatage des divers événements qu'elle reçoit, il doit fort probablement utiliser ce modèle de conception.

Squelette de ce modèle de conception

Vous pouvez fractionner le code d'une logique applicative qui utilise ce modèle en deux parts : un cadre et une implémentation. Le cadre contient un code qui dans la plupart des cas est fixé et ne change pas pour les diverses logiques applicatives. Cette partie est la même pour le calcul de disponibilité et le nombre de tickets non résolus à temps. L'implémentation contient un code qui est spécifique à chaque logique applicative.

Il est recommandé de mettre ces deux parties du code dans des modules de logique applicative distincts et de réutiliser le module de la structure dans des métriques différentes.

Voici le code de la structure :

Dim g_PrevEventTimestamp

Sub OnLoad(time)
     g_PrevEventTimestamp = time
     InitializeStatusVariables
End sub

Sub OnRegistration(Dispatcher)
     'S'il y a une copie distincte de variables de statut 
     'Pour chaque ressource enregistrée dépendre des ressources enregistrées
     'Vous devriez définir des valeurs initiales sur les
     'Variables de statut des ressources nouvellement ajoutées ici
End sub

Sub OnPeriodStart(time)
     InitializeCounters
End sub

Sub OnPeriodEnd(time, completePeriod)
     HandleEvent (time)
End sub

Sub OnTimeslotEnter(time)
     HandleEvent (time)
End sub

Sub OnTimeslotExit(time)
     HandleEvent (time)
End sub


Function Result()
     Result = CalculateResult()
End Function

Sub HandleEvent(Time)
     Dim diff
     diff = TimeDiff( "s",Time,g_PrevEventTimestamp)
     UpdateCounters(diff)
     g_PrevEventTimestamp = Time
End sub

Voici un squelette du module d'implémentation :

'Définissez vos variables de statut ici. Ce peut être une 
'Simple variable globale ou de nombreuses variables globales complexes
'Selon la logique applicative
Dim g_StatusVar_1, g_StatusVar_2, ... ,g_StatusVar_n

'Définissez vos compteurs ici. 
'Cela peut être une simple variable globale ou de nombreuses
'Variables globales complexes selon la logique applicative
Dim g_Counter_1, g_Counter_2, ... , g_Counter_n

Sub InitializeStatusVariables ()
     'Définir des valeurs initiales sur les diverses variables de statut
End sub

Sub InitializeCounters ()
     'Définir des valeurs initiales sur les divers compteurs
     g_Counter_1 = 0
     g_Counter_2 = 0
     '…
     g_Counter_n = 0
End sub

Function CalculateResult ()
     'Calculer le résultat. Le résultat doit varier selon
     'Les valeurs des compteurs. Il ne doit pas varier selon
     'La valeur des variables de statut. Il ne doit pas 
     'Modifier les valeurs des compteurs ou les variables 
     'de statut
End Function

Sub UpdateStatus(method, eventDetails)
     'Mettre à jour la valeur des variables de statut selon
     'Les paramètres (et probablement selon l'ancienne valeur des 
     'Variables de statut)
End sub

Sub UpdateCounters(diff)
     'Mettre à jour les valeurs des compteurs selon leur
     'Valeur précédente, selon la valeur des variables de statut
     'Et selon la valeur du paramètre de diff.
     'Dans beaucoup de cas, ce calcul varie également selon la
     'Valeur de Context.IsWithinTimeslot
End sub

Sub OnEvent_1(eventDetails)
     HandleEvent (eventDetails.Time)
     UpdateStatus("OnEvent_1",eventDetails)
End sub

Sub OnEvent_2(eventDetails)
     HandleEvent (eventDetails.Time)
     UpdateStatus("OnEvent_2",eventDetails)
End sub

'...

Sub OnEvent_n(eventDetails)
     HandleEvent (eventDetails.Time)
     UpdateStatus("OnEvent_n",eventDetails)
End sub

Afin de mieux expliquer ce modèle de conception, voici un exemple d'implémentation de ce modèle permettant de calculer la disponibilité. Cet exemple suppose qu'il existe des événements pour HAUT et BAS gérés par deux gestionnaires d'événements distincts dans la logique applicative. La disponibilité est définie comme le pourcentage de durée pendant laquelle le système affiche une durée supérieure à la durée totale de la période d'application. Il est supposé que le statut du système est le statut du dernier événement reçu (HAUT ou BAS).

Voici le code d'implémentation (le code du cadre reste inchangé) :

'Variable de statut
Dim g_Status
'Compteurs.
Dim g_UpTime, g_TotalTime

Sub InitializeStatusVariables ()
     G_Status = “UP”
End sub

Sub InitializeCounters ()
     g_UpTime = 0
     g_TotalTime = 0
End sub

Function CalculateResult ()
     If g_TotalTime = 0 Then
          CalculateResult = Null
     Else
          CalculateResult = g_UpTime/g_TotalTime*100
     End If
End Function

Sub UpdateStatus(method, eventDetails)
     If method = “OnUP” Then
          G_Status = “UP”
     Else
          G_Status = “DOWN”
     End If
End sub

Sub UpdateCounters(diff)
     If Context.IsWithinTimeslot Then
          G_TotalTime = g_TotalTime + diff
          If g_Status = “UP” Then
               G_UpTime = g_UpTime + diff
          End If
     End If
End sub

Sub OnUp(eventDetails)
     HandleEvent (eventDetails.Time)
     UpdateStatus(“OnUp”,eventDetails)
End sub

Sub OnDown(eventDetails)
     HandleEvent (eventDetails.Time)
     UpdateStatus(“OnDown”,eventDetails)
End sub

Ce modèle présente plusieurs variations. Une des variations les plus communes est lorsqu'un compteur de temps distinct doit être maintenu pour des entités différentes. Par exemple, lorsque nous évaluons le temps de résolution, un compteur distinct doit être maintenu pour chaque ticket ouvert. Dans ce cas lors de la gestion d'un événement ne concernant qu'un ticket, il est plus judicieux de mettre à jour uniquement le compteur de ce ticket. Lorsqu'un événement commun est géré (comme l'OnPeriodEnd ou l'OnTimeslotEnter), les compteurs de tous les tickets doivent être mis à jour.

Remarque : Cette variation du modèle nécessite le maintien d'une copie distincte de la variable globale de g_PrevEventTimestamp de chaque ticket.

Vous pouvez consulter quelques exemples appropriés de l'utilisation de ce modèle dans notre contenu prédéfini. Rappelez-vous cependant que ce modèle est utilisé un peu différemment dans le contenu prédéfini et que la distinction entre la structure et l'implémentation n'est pas si évidente dans ce cas là.