Doc Technique - RMF / CMF Analyzer V2

RMF / CMF Analyzer V2 – Analyseur intelligent des rapports DASD mainframe

Objectif du guide

Installer, tester et exploiter le script rmf_cmf_analyzer_v2.py, capable de parser des rapports RMF / CMF orientés stockage DASD, de normaliser les métriques I/O et de générer un diagnostic lisible.

Les rapports RMF et CMF sont historiquement très précis, mais difficiles à lire dès que l’on passe à des centaines ou milliers de volumes. Cette V2 transforme les listings en données structurées, puis classe les devices et volumes selon leur criticité performance.

Télécharger l’utilitaire RMF / CMF Analyzer V2

Bouton principal vers le script Python à déposer dans /static/toolbox/rmf_cmf_analyzer_v2.py.

Download rmf_cmf_analyzer_v2.py Download sample .rmf

Parser

Lecture des formats IBM RMF DASD, Shared DASD et variantes CMF proches.

Analyzer

Calcul des scores, détection des anomalies et tri des volumes sensibles.

Exporter

Production de rapports HTML, JSON, CSV records et CSV issues.

Ce que le moteur analyse

Métrique	Lecture opérationnelle	Symptôme possible
`RESP`	Temps de réponse global de l’I/O.	Latence visible par le workload.
`IOSQ`	Temps passé en file d’attente I/O côté système.	Contention locale, queue depth, mauvais équilibrage.
`PEND`	Temps d’attente avant prise en charge par le sous-système.	Pathing, control unit, saturation front-end ou FICON.
`DISC`	Temps où le device est déconnecté pendant le service de l’I/O.	Backend delay, activité contrôleur, comportement cache.
`CONN`	Temps réel de connexion channel-device.	Transfert long, device lent, charge séquentielle lourde.
`% DEV UTIL`	Taux d’utilisation du volume ou device.	Hot volume, volume trop sollicité, déséquilibre.

Positionnement : ce guide est conçu pour un usage labo, audit, avant/après migration storage, préparation d’un futur moteur expert, ou démonstrateur technique pour anciens environnements IBM Z / EMC / HDS / DS8K.

Important : le fichier RMF fourni pour les tests est synthétique mais réaliste. Il sert à valider les règles, les exports et la robustesse du parser sans exposer de données confidentielles issues d’un centre informatique réel.

Installation du parseur RMF / CMF Analyzer V2

Le script est volontairement autonome. Il ne nécessite ni Django, ni base SQL, ni package externe. Une version Python moderne suffit. Il peut donc tourner sur un poste Windows, Linux, macOS ou sur un serveur d’audit.

1. Arborescence recommandée

rmf_cmf_lab/
  bin/
    rmf_cmf_analyzer_v2.py
  input/
    sample_rmf_shared_dasd_activity.rmf
  output/
    reports/
    csv/
    json/

2. Copie du script

Placer le fichier rmf_cmf_analyzer_v2.py dans un répertoire dédié, par exemple bin/.

Lien de téléchargement direct du script Python

Ce bouton pointe explicitement vers /static/toolbox/rmf_cmf_analyzer_v2.py.

Download rmf_cmf_analyzer_v2.py Django static tag

mkdir -p rmf_cmf_lab/bin rmf_cmf_lab/input rmf_cmf_lab/output/reports rmf_cmf_lab/output/csv rmf_cmf_lab/output/json
cp rmf_cmf_analyzer_v2.py rmf_cmf_lab/bin/
cp sample_rmf_shared_dasd_activity.rmf rmf_cmf_lab/input/
cd rmf_cmf_lab
python3 bin/rmf_cmf_analyzer_v2.py --demo

New-Item -ItemType Directory -Force rmf_cmf_lab\bin, rmf_cmf_lab\input, rmf_cmf_lab\output\reports, rmf_cmf_lab\output\csv, rmf_cmf_lab\output\json
Copy-Item .\rmf_cmf_analyzer_v2.py .\rmf_cmf_lab\bin\
Copy-Item .\sample_rmf_shared_dasd_activity.rmf .\rmf_cmf_lab\input\
Set-Location .\rmf_cmf_lab
python .\bin\rmf_cmf_analyzer_v2.py --demo

3. Intégration dans un projet Django / IDEO-Lab

Si tu veux l’exposer depuis un guide Django, le plus simple est de déposer le script et l’input de test dans static/toolbox/, puis d’utiliser des liens de téléchargement.

static/
  toolbox/
    rmf_cmf_analyzer_v2.py
    sample_rmf_shared_dasd_activity.rmf
    rmf_cmf_analyzer_v2_guide.html

Validation rapide : si python rmf_cmf_analyzer_v2.py --demo affiche un résumé et un top des devices, l’environnement Python est suffisant pour passer aux vrais fichiers input.

Fichiers input attendus

La V2 attend un fichier texte brut contenant un rapport RMF ou CMF. L’extension importe peu : .txt, .rmf, .lst ou .log. Le point clé est que les lignes de données DASD soient lisibles en texte, avec les colonnes de temps et d’activité.

1. Exemple minimal de rapport RMF-like

Utilitaire nécessaire pour tester ce fichier input

Télécharger d’abord le script Python, puis lancer l’analyse sur le fichier .rmf ci-dessous.

Download rmf_cmf_analyzer_v2.py

DEVICE   DEV   VOLUME   LCU    ACTIVITY   RESP   IOSQ   PEND   DISC   CONN   %UTIL
02180    33909 PAY001   0100   120.450    0.620  0.020  0.030  0.290  0.280  18.40
02181    33909 PAY002   0100   365.700    8.920  5.100  0.220  1.700  1.900  76.20
02182    33909 PAY003   0100   412.330    12.800 0.120  8.700  2.100  1.880  81.00
02183    33909 LOG001   0101   950.120    18.400 0.400  0.650  14.200 3.150  88.90

2. Sources possibles

Source	Format attendu	Usage
RMF Postprocessor	Listing texte DASD Activity / Shared DASD Activity.	Analyse de performance z/OS classique.
CMF Analyzer	Listing texte Device Activity / Shared Device Activity.	Analyse BMC équivalente ou complémentaire.
Export spool	Fichier texte issu de JES / SDSF / outil interne.	Analyse offline hors mainframe.
Fichier synthétique	Rapport généré pour tests et scénarios contrôlés.	Développement, démonstration, non-régression.

3. Préparation d’un vrai listing

Exporter le rapport en texte brut, pas en image ni en PDF scanné.
Conserver les entêtes de colonnes si possible : ils aident à vérifier visuellement le format.
Éviter les conversions qui compressent les espaces ou tronquent les colonnes.
Anonymiser les noms de volumes, systèmes, LPAR ou applications si le rapport vient d’un environnement client.

Règle de sécurité : un vrai rapport RMF/CMF peut révéler des noms de volumes, classes de workloads, heures de batch, topologie storage et indices de volumétrie. Il faut toujours anonymiser avant partage.

Utilisation quotidienne

1. Mode démo intégré

Le mode démo permet de vérifier que le script fonctionne même sans fichier RMF externe.

python rmf_cmf_analyzer_v2.py --demo

2. Analyse simple d’un fichier RMF

python rmf_cmf_analyzer_v2.py input/sample_rmf_shared_dasd_activity.rmf

3. Analyse avec tous les exports

python rmf_cmf_analyzer_v2.py input/sample_rmf_shared_dasd_activity.rmf \
  --json output/json/rmf_analysis.json \
  --csv-records output/csv/rmf_records.csv \
  --csv-issues output/csv/rmf_issues.csv \
  --html output/reports/rmf_report.html

4. Analyse stricte pour batch ou CI

Le paramètre --fail-on-critical force un code retour non nul si des anomalies critiques sont détectées. Cela permet d’intégrer le script dans un job batch, un contrôle qualité, ou une chaîne d’audit automatisée.

python rmf_cmf_analyzer_v2.py input/nightly_rmf_dasd.rmf \
  --html output/reports/nightly_rmf_dasd.html \
  --csv-issues output/csv/nightly_rmf_issues.csv \
  --fail-on-critical

Lecture recommandée : commencer par le rapport HTML pour l’humain, puis utiliser le JSON/CSV pour brancher des dashboards, alimenter une base SQL ou comparer plusieurs périodes.

Paramètres de ligne de commande

La V2 a été pensée pour rester simple à lancer, mais assez configurable pour adapter les seuils à un contexte mainframe réel. Les seuils par défaut sont utiles en démonstration, mais doivent être ajustés selon l’environnement.

1. Paramètres d’entrée et de sortie

Paramètre	Description	Exemple
`input_file`	Fichier RMF/CMF texte à analyser.	`input/rmf_report.rmf`
`--demo`	Lance une analyse avec un jeu de données interne.	`--demo`
`--json`	Génère le résumé complet en JSON.	`--json output/rmf.json`
`--csv-records`	Exporte les lignes normalisées, une ligne par device/volume.	`--csv-records output/records.csv`
`--csv-issues`	Exporte les anomalies détectées par le rules engine.	`--csv-issues output/issues.csv`
`--html`	Génère un rapport HTML lisible par un ingénieur ou un manager.	`--html output/report.html`
`--fail-on-critical`	Retourne une erreur si au moins une anomalie critique existe.	`--fail-on-critical`

2. Paramètres de seuils

Paramètre	Mesure	Quand l’utiliser
`--warn-response-ms`	Seuil warning du temps de réponse global.	Pour rendre l’outil plus ou moins sensible à la latence globale.
`--critical-response-ms`	Seuil critique du temps de réponse global.	Pour déclencher les alertes majeures.
`--warn-iosq-ms`	Seuil warning du temps IOSQ.	Pour détecter la contention ou les queues locales.
`--critical-iosq-ms`	Seuil critique du temps IOSQ.	Pour isoler les volumes avec attente système importante.
`--warn-pending-ms`	Seuil warning du temps pending.	Pour repérer les problèmes potentiels côté path/control unit.
`--critical-pending-ms`	Seuil critique du temps pending.	Pour classer les anomalies storage/pathing les plus sérieuses.
`--warn-utilization-pct`	Seuil warning d’utilisation device.	Pour détecter les hot volumes.
`--critical-utilization-pct`	Seuil critique d’utilisation device.	Pour isoler les devices très sollicités.

3. Exemple avec seuils personnalisés

python rmf_cmf_analyzer_v2.py input/sample_rmf_shared_dasd_activity.rmf \
  --warn-response-ms 8 \
  --critical-response-ms 20 \
  --warn-iosq-ms 1 \
  --critical-iosq-ms 4 \
  --warn-pending-ms 1 \
  --critical-pending-ms 4 \
  --warn-utilization-pct 70 \
  --critical-utilization-pct 90 \
  --html output/reports/rmf_custom_thresholds.html

Attention aux seuils universels : un environnement batch lourd, DB2 très actif ou un système bancaire transactionnel n’ont pas les mêmes profils. Les seuils doivent être calibrés après observation de plusieurs périodes.

Exemples d’utilisation

Scénario 1 – Audit rapide après incident batch

On dispose d’un listing généré après un ralentissement nocturne. Objectif : obtenir rapidement les volumes les plus suspects.

python rmf_cmf_analyzer_v2.py input/batch_window_0200_0400.rmf \
  --html output/reports/batch_window_0200_0400.html \
  --csv-issues output/csv/batch_window_issues.csv

Scénario 2 – Comparaison avant/après migration storage

La V2 ne fait pas encore le diff automatique, mais ses exports CSV/JSON permettent déjà de comparer deux fenêtres dans Excel, Python, SQL ou Power BI.

python rmf_cmf_analyzer_v2.py input/before_migration.rmf \
  --csv-records output/csv/before_records.csv \
  --csv-issues output/csv/before_issues.csv \
  --html output/reports/before_migration.html

python rmf_cmf_analyzer_v2.py input/after_migration.rmf \
  --csv-records output/csv/after_records.csv \
  --csv-issues output/csv/after_issues.csv \
  --html output/reports/after_migration.html

Scénario 3 – Exécution nocturne automatisée

Exemple de lancement quotidien avec conservation du rapport HTML et du CSV des anomalies.

0 5 * * * /opt/rmf-cmf/bin/python /opt/rmf-cmf/rmf_cmf_analyzer_v2.py \
  /data/rmf/nightly_dasd_activity.rmf \
  --html /var/www/reports/rmf/nightly_dasd_activity.html \
  --csv-issues /var/log/rmf/nightly_dasd_issues.csv \
  --json /var/log/rmf/nightly_dasd_analysis.json \
  --fail-on-critical >> /var/log/rmf/rmf_cmf_analyzer.log 2>&1

Scénario 4 – Test de non-régression du parser

À chaque évolution du parser, relancer le sample synthétique et vérifier que les records et issues attendus sont produits.

python rmf_cmf_analyzer_v2.py input/sample_rmf_shared_dasd_activity.rmf \
  --json output/json/sample_analysis.json \
  --csv-records output/csv/sample_records.csv \
  --csv-issues output/csv/sample_issues.csv \
  --html output/reports/sample_report.html

Bonne pratique : garder une bibliothèque de samples synthétiques : IOSQ élevé, pending élevé, disconnect dominant, connect élevé, hot volume, faible activité mais forte latence, etc.

Exports et exploitation des résultats

La V2 produit quatre familles de sorties. Elles n’ont pas le même usage : le HTML pour lecture humaine, le JSON pour intégration technique, les CSV pour Excel/SQL/BI.

Rapport HTML

Vue synthétique avec compteur de records, sévérités, top suspects et détails des anomalies.

Analyse JSON

Format complet pour API, ingestion SQL, stockage historique ou comparaison automatique.

Records CSV

Une ligne par device ou volume normalisé, pratique pour pivot table et audit brut.

Issues CSV

Une ligne par anomalie détectée, avec sévérité, code et explication courte.

1. Exemple de synthèse console

RMF / CMF records parsed : 36
Devices                 : 12
Volumes                 : 12
Issues                  : 105
Critical                : 44
Warnings                : 61

TOP BY SCORE
LOG001   RESP=18.400 IOSQ=0.400 PEND=0.650 DISC=14.200 CONN=3.150 UTIL=88.90
PAY003   RESP=12.800 IOSQ=0.120 PEND=8.700 DISC=2.100  CONN=1.880 UTIL=81.00
PAY002   RESP=8.920  IOSQ=5.100 PEND=0.220 DISC=1.700  CONN=1.900 UTIL=76.20

2. Exploitation SQL possible

Les CSV peuvent être chargés dans MariaDB, PostgreSQL, DB2 LUW ou SQLite pour historisation. Une table simple peut suffire pour commencer.

CREATE TABLE rmf_dasd_record (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    run_id BIGINT NOT NULL,
    device VARCHAR(32),
    volume VARCHAR(32),
    lcu VARCHAR(32),
    activity_rate DECIMAL(18,6),
    response_time_ms DECIMAL(18,6),
    iosq_time_ms DECIMAL(18,6),
    pending_time_ms DECIMAL(18,6),
    disconnect_time_ms DECIMAL(18,6),
    connect_time_ms DECIMAL(18,6),
    device_util_pct DECIMAL(18,6),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

3. Roadmap naturelle V3

Diff engine comparaison automatique avant/après migration storage.
Expert rules règles dédiées EMC Symmetrix/VMAX, IBM DS8K, HDS/VSP.
HTML dashboard heatmaps par heure, LCU, volume, device type.
SQL history historisation des runs et tendances sur plusieurs semaines.
AI summary résumé exécutif automatique pour manager ou consultant.

Vision produit : le parseur n’est que la première brique. La valeur réelle est dans le moteur de diagnostic, le scoring, l’historisation et la synthèse actionnable pour ingénieurs storage/mainframe.

Dépannage et bonnes pratiques

1. Le script ne parse aucune ligne

Cause possible	Correction
Le fichier est un PDF scanné ou une image.	Exporter en texte brut depuis le spool ou utiliser un OCR avant le parser.
Les colonnes ont été cassées par copier/coller.	Utiliser un export fixe, conserver les espaces et éviter les conversions Word.
Le rapport n’est pas un rapport DASD/Device Activity.	Vérifier que les colonnes `RESP`, `IOSQ`, `PEND`, `DISC`, `CONN` existent.
Format RMF/CMF différent.	Créer un nouveau parser sectionnel dédié et l’ajouter au moteur V2.

2. Les scores semblent trop agressifs

Ajuster les seuils. En environnement réel, il faut calibrer avec plusieurs jours de rapports, séparer les fenêtres online et batch, puis fixer des seuils par contexte.

python rmf_cmf_analyzer_v2.py input/production_window.rmf \
  --warn-response-ms 15 \
  --critical-response-ms 35 \
  --warn-iosq-ms 3 \
  --critical-iosq-ms 8 \
  --warn-pending-ms 3 \
  --critical-pending-ms 8 \
  --html output/reports/production_window.html

3. Check-list avant analyse d’un vrai rapport client

Anonymiser les noms de volumes, systèmes, pools, applications et horaires sensibles.
Conserver une copie brute non modifiée pour vérifier les erreurs de parsing.
Noter la fenêtre de temps du rapport : online, batch, clôture, sauvegarde, fin de mois.
Comparer les métriques avec le contexte métier : un volume très actif n’est pas forcément anormal.
Ne jamais conclure uniquement avec %UTIL : toujours corréler RESP, IOSQ, PEND, DISC, CONN.

Point critique : un diagnostic RMF/CMF sérieux ne doit jamais se limiter à une alerte isolée. La bonne analyse consiste à reconstruire la chaîne I/O : attente système, pathing, contrôleur, cache, backend et workload.