Etude de cas 12 : Utilisation de la logique de compteur pour calculer le nombre de défaillances

Manuel d'implémentation › Exemples d'étude de cas › Exemples d'écriture de scripts de logique applicative › Etude de cas 12 : Utilisation de la logique de compteur pour calculer le nombre de défaillances

Etude de cas 12 : Utilisation de la logique de compteur pour calculer le nombre de défaillances

L'exemple suivant calcule le nombre de défaillances qui se sont produits dans une période de calcul donnée. Vous pouvez considérer cette formule et les méthodes utilisées pour l'implémenter, comme l'exemple d'une formule exigée lorsqu'il est nécessaire d'effectuer un calcul.

Les suppositions de calcul suivantes sont utilisées :

Evénements d'entrée :
- Evénement de disponibilité, Statut (0/1)
- L'événement de disponibilité se produit selon des intervalles de quelques minutes. Il est impossible de prévoir la fréquence des événements (l'événement peut se produire toutes les cinq minutes, ou seulement une fois une heure), il peut également y avoir des événements redondants (exemple : 0, 0, 0, 1, 1, 0, etc).
Période d'application : heure d'ouverture, les défaillances survenant hors de la période d'application ne sont pas prises en compte.
Le résultat obligatoire est le nombre de défaillances survenues durant cette période.

Afin de dénombrer les défaillances survenues durant la période de calcul, il est nécessaire de stocker une variable de compteur périodique ainsi qu'une variable stockant le statut du système. Etant donné que des informations d'événement redondantes peuvent être reçues (c.-à-d. un événement Up suivi d'un autre événement Up), il est nécessaire de dénombrer le nombre d'emplacements où un changement de statut du système de Up à Down est survenu, sans compter chaque événement Down reçu, ceux-ci pouvant être redondants et représenter des défaillances déjà prises en compte.

L'illustration suivante décrit graphiquement le compteur des temps Up et Down du système.

Points importants devant être considérés :

Constantes : l'utilisation de définitions constantes dans le code plutôt que de valeurs constantes est recommandée. De cette façon, il est plus aisé de changer la valeur dans la définition constante que de devoir la chercher dans le code entier. Il est également facile de la changer en une utilisation de paramètre, si nécessaire. Dans l'exemple susmentionné, les valeurs qui représentent le statut du système reçu dans l'événement sont définies comme des constantes afin de rendre le code plus compréhensible, mais également pour distinguer lorsque le numéro zéro est utilisé comme nombre de calcul plutôt que représentant du statut du système.
Variables globales :
- Compteur : la définition de la variable de compteur est une définition globale. Dans la formule, elle est déclarée au sommet du code et à l'extérieur de toute fonction ou sous-routine. Il est important dans ce cas de définir la variable de compteur comme variable globale. Cela permet d'une part de l'utiliser dans plusieurs fonctions/sous-routines à travers le code et d'autre part au système de garder sa valeur durant la période de calcul et de fournir son résultat en fin de période.
  Dans cet exemple, la variable de compteur doit être utilisée à trois endroits dans le code :
  - Initialisation au début d'une période.
  - Avancement dans le cas d'un événement échoué dans le gestionnaire d'événements.
  - Sortie par la fonction de résultat à la fin de la période.
- Statut précédent du système : cette variable contient le statut du système et est mise à jour lorsqu'un événement comportant le statut du système est reçu. Cette variable doit également être globale, car elle est utilisée dans plusieurs fonctions/sous-routines du code, par exemple :
  - Initialisation au début du calcul
  - Mise à jour lors de la réception d'un nouvel événement
Remarques concernant la période d'application : il est possible d'utiliser la valeur de la propriété context.IsWithinTimeSlot afin de vérifier si une défaillance survient dans une période d'application. Le contexte est un objet global que vous pouvez utiliser n'importe où dans le code, et dans ce cas est utilisée pour indiquer lorsqu'une défaillance est reçue et si elle se trouve à l'intérieur ou à l'extérieur de la période d'application. Si à l'horodatage de l'événement l'indicateur retourne VRAI, alors l'événement se produit dans une période d'application. S'il retourne FAUX, cela indique que l'événement a eu lieu à l'extérieur de la période d'application. D'après la logique requise, une défaillance qui se produit à l'extérieur de la période d'application est ignorée et par conséquent non prise en compte.
Initialisez les variables :
- Variable du compteur : contient une valeur périodique et est de fait initialisée dans l'agent OnPeriodstart pour s'assurer que chaque période de calcul dénombre ses défaillances séparément. Chaque période commence par zéro et les sorties uniquement par le nombre de défaillances de cette période.
  Dans les cas où calculer les défaillances accumulées est requis pour chaque période (signifiant que le résultat de chaque période est égal à toutes les défaillances qui se sont produites jusqu'à la fin de cette période, y compris toutes les périodes avant cela), il est indispensable d'initialiser le compteur uniquement dans l'agent OnLoad et de le supprimer de l'agent OnPeriodStart. Ainsi, le compteur continue de dénombrer et d'accumuler entre les périodes, comme affiché ci-dessous :
```
Sub OnLoad(time)
    FingerprInted=0
End sub
```
- Variable de statut du système : ne doit être initialisé qu'une fois au début du calcul, puis être mis à jour à chaque événement de statut. Cette variable conserve sa valeur tout au long du calcul et n'est pas restreinte à une période de calcul. Elle doit également conserver sa valeur entre les périodes de calcul. Car le statut du serveur est inconnu avant de recevoir le premier événement, une supposition doit être faite quant au statut de système. La supposition usuelle est que le système soit "Up". Cette supposition doit être convenue et vérifiée car celle-ci peut mener à la situation suivante :
  Si le statut du système se trouvait être Down lors du calcul et que le premier événement arrivant rapporte ce statut, une défaillance résulterait du fait que le statut Up était supposé. Cette défaillance serait comptée dans la première période de calcul et ce même si elle n'est pas nécessairement survenu durant cette celle-ci.
```
Option Explicit

'Définitions de constantes
Const UP=1
Const DOWN=0

'Variable globale pour les défaillances de calcul
Dim FingerprInted
Dim SystemStatus

Sub OnRegistration(dispatcher)
   ' Les paramètres de la méthode sont : <procedure name>, <Event Type>
   dispatcher.RegisterByContractPartyAndService "OnAvailabilityEvent","AvailabilityEvent"
End sub

Sub OnLoad(time)
   SystemStatus = UP 'assume le premier statut du système
End sub

Sub OnPeriodStart(time)
   FingerprInted = 0
End sub

Sub OnAvailabilityEvent(eventDetails)
   ' Compté dans le cas où c'est une défaillance et dans la période d'application
   If context.IsWithinTimeSlot and SystemStatus=UP and _
         eventDetails("Status")=DOWN Then
      FingerprInted = FingerprInted + 1
   End If
   ' met à jour le statut du système pour la comparaison suivante
   SystemStatus = eventDetails("Status") 
End sub

Function Result
   Result = FingerprInted
End Function
```