ajout de doc

CREATE_FIREWALL_PARSING.md

@@ -0,0 +1,222 @@
+
+# Guide de Développement : Créer son propre Parseur Firewall
+
+Ce guide explique comment étendre l'outil d'analyse réseau en ajoutant un nouveau parseur pour un modèle de firewall non supporté nativement (ex: CheckPoint, Fortinet, etc.).
+
+> **Note :** Tout au long de ce guide, remplacez **`MODELE`** (en majuscule ou minuscule) par le nom de la marque ou du modèle du firewall ciblé.
+
+---
+
+## Étape 1 : Création du script de parsing
+
+Dans le dossier `Parseurs_config_Firewall/src/scripts/` (ou `script/` selon votre arborescence), créez un nouveau fichier Python nommé **`json_MODELE.py`**.
+
+*Il est fortement recommandé de s'inspirer des parseurs existants comme `json_Forcepoint.py`, `json_Stormshield.py` ou `json_PaloAlto.py`.*
+
+Voici le squelette de code à utiliser (exemple basé sur des logs au format XML) :
+
+```python
+#!/usr/bin/env python3
+"""
+Parser pour configuration MODELE XML vers un format json normalisé OpenConfig YANG
+Extrait les groupes d'objets, objets, groupes de services, services, routes, interfaces et règles
+"""
+
+import xml.etree.ElementTree as ET
+import json
+from scripts.export_modele import ParserMixin
+from scripts.objets.data import AddressObject, AddressGroup, ServiceObject, ServiceGroup, Interface, SecurityRule, StaticRoute, VirtualRouter
+from pathlib import Path
+
+class ModeleParser(ParserMixin):
+    """Parser pour fichier Modele"""
+    
+    def __init__(self, xml_file_path: str):
+        """Initialise le parser avec le chemin du fichier"""
+        self.xml_file = xml_file_path
+        self.tree = None
+        self.root = None
+        self.config = {
+            'address_objects': [],
+            'address_groups': [],
+            'service_objects': [],
+            'service_groups': [],
+            'interfaces': [],
+            'virtual_routers': [],
+            'static_routes': [],
+            'security_rules': []
+        }
+        
+    def load_xml(self):
+        """Charge le fichier XML"""
+        try:
+            self.tree = ET.parse(self.xml_file)
+            self.root = self.tree.getroot()
+            print(f"✓ Fichier XML chargé: {self.xml_file}")
+        except ET.ParseError as e:
+            print(f"✗ Erreur de parsing XML: {e}")
+            raise
+        except FileNotFoundError:
+            print(f"✗ Fichier non trouvé: {self.xml_file}")
+            raise
+    
+    def _parse_address_objects(self):
+        """Parse les objets adresse"""
+        address_objects = []
+        
+        # TODO: Parcourir le XML et instancier des objets AddressObject
+        
+        self.config['address_objects'] = address_objects
+        print(f"✓ Trouvé {len(address_objects)} objets adresse")
+    
+    def _parse_address_groups(self):
+        """Parse les groupes d'adresses"""
+        address_groups = []
+        
+        # TODO: Parcourir le XML et instancier des objets AddressGroup
+        
+        self.config['address_groups'] = address_groups
+        print(f"✓ Trouvé {len(address_groups)} groupes d'adresses")
+    
+    def _parse_service_objects(self):
+        """Parse les objets service"""
+        service_objects = []
+        
+        # TODO: Parcourir le XML et instancier des objets ServiceObject
+        
+        self.config['service_objects'] = service_objects
+        print(f"✓ Trouvé {len(service_objects)} objets service")
+    
+    def _parse_service_groups(self):
+        """Parse les groupes de services"""
+        service_groups = []
+        
+        # TODO: Parcourir le XML et instancier des objets ServiceGroup
+        
+        self.config['service_groups'] = service_groups
+        print(f"✓ Trouvé {len(service_groups)} groupes de services")
+    
+    def _parse_interfaces(self):
+        """Parse les interfaces réseau"""
+        interfaces = []
+        
+        # TODO: Parcourir le XML et instancier des objets Interface
+        
+        self.config['interfaces'] = interfaces
+        print(f"✓ Trouvé {len(interfaces)} interfaces")
+
+    def _parse_virtual_routers(self):
+        """Parse les virtual-routers et leurs routes statiques"""
+        virtual_routers = []
+
+        # TODO: Parcourir le XML, instancier des VirtualRouter et injecter les StaticRoute
+
+        self.config['virtual_routers'] = virtual_routers
+        print(f"✓ Trouvé {len(virtual_routers)} virtual-routers")
+    
+    def _parse_security_rules(self):
+        """Parse les règles de sécurité"""
+        security_rules = []
+
+        # TODO: Parcourir le XML et instancier des objets SecurityRule
+        
+        self.config['security_rules'] = security_rules
+        print(f"✓ Trouvé {len(security_rules)} règles de sécurité")
+    
+    def parse_all(self):
+        """Parse tous les éléments de configuration"""
+        print("Début du parsing de la configuration MODELE...")
+        
+        self.load_xml()
+        self._parse_address_objects()
+        self._parse_address_groups()
+        self._parse_service_objects()
+        self._parse_service_groups()
+        self._parse_interfaces()
+        self._parse_virtual_routers()
+        self._parse_security_rules()
+        
+        print("✓ Parsing terminé avec succès!")
+    
+    def export_to_json(self, output_file: str):
+        """Exporte la configuration au format JSON OpenConfig"""
+        fw_name = ""
+        deviceconfig = self.root.find(".//deviceconfig/system/hostname")
+        if deviceconfig is not None and deviceconfig.text:
+            fw_name = deviceconfig.text.strip()
+            
+        openconfig_data = self.to_openconfig_yang("MODELE", [fw_name])
+        
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(openconfig_data, f, indent=2, ensure_ascii=False)
+        
+        print(f"✓ Configuration exportée vers: {output_file}")
+    
+def generate_json_modele(input_file: str, output_file: str):
+    """Génère le fichier JSON OpenConfig à partir du fichier XML MODELE"""
+    xml_file = Path(input_file)
+    if not xml_file.exists():
+        print(f"✗ Erreur: Le fichier '{xml_file}' n'existe pas")
+        return
+    
+    try:
+        parser = ModeleParser(str(xml_file))
+        parser.parse_all()
+        parser.print_summary()
+        parser.export_to_json(output_file)
+        print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
+    except Exception as e:
+        print(f"✗ Erreur: {e}")
+        return
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) != 2:
+        print("Usage: python json_MODELE.py <fichier_config.xml>")
+        sys.exit(1)
+        
+    xml_file = sys.argv[1]
+    if not Path(xml_file).exists():
+        print(f"✗ Erreur: Le fichier '{xml_file}' n'existe pas")
+        sys.exit(1)
+        
+    try:
+        parser = ModeleParser(xml_file)
+        parser.parse_all()
+        parser.print_summary()
+        output_file = 'output_Modele.json'
+        parser.export_to_json(output_file)
+        print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
+    except Exception as e:
+        print(f"✗ Erreur: {e}")
+        sys.exit(1)
+
+```
+
+## Étape 2 : Intégration dans le moteur principal (`main.py`)
+
+Pour que le script global prenne en charge le nouveau modèle, ouvrez le fichier `Parseurs_config_Firewall/src/main.py` :
+
+1. Importez votre nouvelle fonction en haut du fichier :
+```python
+from scripts.json_MODELE import generate_json_modele
+```
+
+2. Ajoutez la condition correspondante dans le bloc de sélection du type de firewall :
+```python
+elif firewall_type == "modele":
+    generate_json_modele(input_data, output_file_json)
+```
+
+3. Mettez à jour les instructions textuelles d'usage affichées dans la console si le paramètre saisi est incorrect afin d'inclure `"modele"` dans la liste des choix valides.
+
+
+## Étape 3 : Adaptation de l'Interface Graphique (GUI)
+
+Afin que le nouveau modèle apparaisse dans l'interface graphique unifiée :
+
+1. Ouvrez le fichier de gestion de la GUI (`gui_firewall.py` racine ou script GUI dédié).
+2. Repérez le composant de sélection (Menu déroulant / ComboBox ou liste de boutons radio) listant les firewalls.
+3. Ajoutez **`MODELE`** à la liste des choix graphiques.
+
+> **Important :** faire attention si le script prend en compte un dossier ou un fichier.

CREATE_SWITCH_PARSING.md

@@ -0,0 +1,424 @@
+
+# Guide de Développement : Créer son propre Parseur Switch
+
+Ce guide explique comment étendre l'outil d'analyse réseau en ajoutant un nouveau parseur pour un modèle de switch non supporté nativement (ex: Cisco Meraki, Nexus, etc.).
+
+> **Note :** Tout au long de ce guide, remplacez **`MODELE`** (en majuscule ou minuscule) par le nom de la marque ou du modèle du switch ciblé.
+
+---
+
+## Étape 1 : Création du script de parsing
+
+Dans le dossier `Parseurs_logs_Switch/src/scripts/` (ou `script/` selon votre arborescence), créez un nouveau fichier Python nommé **`json_MODELE.py`**.
+
+*Il est fortement recommandé de s'inspirer des parseurs existants comme `json_hpe.py`.*
+
+Voici le squelette de code à utiliser (exemple basé sur des logs au format XML) :
+
+```python
+#!/usr/bin/env python3
+"""
+Parser pour configuration switch MODELE vers un format json normalisé OpenConfig YANG
+Extrait les différentes sections de logs et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
+"""
+
+import json
+import re
+from scripts.export_modele import ParserMixin
+from scripts.objets.data import MacAddress, Arp, Route, FIB, SlotInfo, VersionInfo, ComponentInfo, SlotManuInfo, ManuInfo, Power, SlotFanInfo, Fan, Sensor, EnvironmentInfo, SlotEnvInfo, SlotBootInfo, IrfMember, IrfLink, IrfTopology, IrfConfiguration, CpuUsage, CpuProcessInfo, ProcessInfo, Memory, TransceiverDiag, Transceiver, TransceiverInterface, Log, Multicast, Qos, Aaa, StpGlobal, StpInfo, StpPort, InterfaceCounter, NetworkInterface, LinkAggregation, ConfigVlan, ConfigIrfPort, ConfigInterface, ConfigAcl, ConfigUser, ConfigSnmp, DeviceConfiguration
+from pathlib import Path
+
+class ModeleParser(ParserMixin):
+    """Parser pour fichier XML MODELE"""
+    
+    def __init__(self, file_path: str):
+        """Initialise le parser avec le chemin du fichier de logs MODELE"""
+        self.file = file_path
+        self.root = None
+        self.raw_data = None
+        self.config = None
+        self.config = {
+            'mac_addresses': [],
+            'arp_table': [],
+            'routing_table': [],
+            'fib_table': [],
+            'version': {},
+            'manuinfo': {},
+            'power': [],
+            'fans': [],
+            'environment': [],
+            'boot_loader': [],
+            'irf': [],
+            'irf_topology': [],
+            'irf_configuration': [],
+            'cpu_process': {},
+            'process': {},
+            'memory': [],
+            'transceiver': [],
+            'transceiver_interface': [],
+            'logbuffer': [],
+            'multicast': [],
+            'qos': [],
+            'aaa': [],
+            'stp': {},
+            'interfaces': [],
+            'link_aggregation': [],
+            'current_configuration': {},
+            'saved_configuration': {}
+        }
+        self.master = None
+        
+    def load_file(self):
+        """Charge le fichier texte brut avec gestion d'encodage"""
+        
+        encodings_to_try = ['utf-8', 'latin-1', 'cp1252']
+
+        for encoding in encodings_to_try:
+            try:
+                with open(self.file, 'r', encoding=encoding) as f:
+                    self.raw_data = f.readlines()
+                print(f"✓ Fichier chargé ({encoding}): {self.file}")
+                return
+
+            except UnicodeDecodeError:
+                continue
+
+        raise ValueError("Impossible de décoder le fichier avec les encodages standards")
+        
+    def _parse_mac_address(self):
+        """Parse display mac-address"""
+        mac_addresses = []
+
+        # TODO: Parcourir les logs et instancier des objets Mac Address
+
+        self.config['mac_addresses'] = mac_addresses
+            
+
+    def _parse_arp_table(self):
+        """Parse display arp all"""
+        arp_table = []
+        
+        # TODO: Parcourir les logs et instancier des objets ARP
+
+        self.config['arp_table'] = arp_table
+
+    def _parse_routing_table(self):
+        """Parse display ip routing-table"""
+        routes = []
+        
+        # TODO: Parcourir les logs et instancier des objets Routing table
+
+        self.config['routing_table'] = routes
+
+    def _parse_fib_table(self):
+        """Parse display fib"""
+        fib_entries = []
+
+        # TODO: Parcourir les logs et instancier des objets FIB
+
+        self.config['fib_table'] = fib_entries
+
+    def _parse_version(self):
+        """Parse display version"""
+        version_info = VersionInfo()
+        
+        # TODO: Parcourir les logs et instancier des objets Version
+
+        self.config["version"] = version_info
+
+    def _parse_device_manuinfo(self):
+        """Parse display device manuinfo"""
+        manuinfo = ManuInfo()
+       
+       # TODO: Parcourir les logs et instancier des objets ManuInfo
+
+        self.config["manuinfo"] = manuinfo
+
+    def _parse_power(self):
+        """Parse display power"""
+        power_data = []
+        
+        # TODO: Parcourir les logs et instancier des objets Power
+
+        self.config["power"] = power_data
+
+    def _parse_fan(self):
+        """Parse display fan"""
+        fan_data = []
+        
+        # TODO: Parcourir les logs et instancier des objets Fan
+
+        self.config["fans"] = fan_data
+
+    def _parse_environment(self):
+        """Parse display environment"""
+        env_data = EnvironmentInfo()
+        
+        # TODO: Parcourir les logs et instancier des objets Environment
+
+        self.config["environment"] = env_data
+
+    def _bootloader_information(self):
+        """Parse boot-loader information"""
+        boot_data = []
+        
+        # TODO: Parcourir les logs et instancier des objets Boot loader
+
+        self.config["boot_loader"] = boot_data
+
+    def _parse_irf(self):
+        """Parse display irf"""
+        irf_data = []
+        
+        # TODO: Parcourir les logs et instancier des objets IRF
+
+        self.config["irf"] = irf_data
+
+    def _parse_irf_topology(self):
+        """Parse display irf topology"""
+        topo = []
+        
+        # TODO: Parcourir les logs et instancier des objets IRF Topology
+
+        self.config["irf_topology"] = topo
+
+    def _parse_irf_configuration(self):
+        """Parse display irf configuration"""
+        config = []
+        
+        # TODO: Parcourir les logs et instancier des objets IRF Configuration
+
+        self.config["irf_configuration"] = config
+
+    def _parse_cpu_process(self):
+        """Parse display process cpu slot [master]"""
+        cpu_data = CpuProcessInfo(slot=self.master)
+        
+        # TODO: Parcourir les logs et instancier des objets CPU Process
+
+        self.config["cpu_process"] = cpu_data
+
+    def _parse_process(self):
+        """Parse display process slot [master]"""
+        process_data = ProcessInfo(slot=self.master)
+        
+        # TODO: Parcourir les logs et instancier des objets Process
+
+        self.config["process"] = process_data
+
+    def _parse_memory(self):
+        """Parse display memory"""
+        memory_data = []
+        
+        # TODO: Parcourir les logs et instancier des objets Memory
+
+        self.config["memory"] = memory_data
+
+    def _parse_transceiver_diagnosis(self):
+        """Parse display transceiver diagnosis interface"""
+        data = []
+
+        # TODO: Parcourir les logs et instancier des objets Transceiver diagnosis
+
+        self.config["transceiver"] = data
+
+    def _parse_transceiver_interface(self):
+        """Parse display transceiver interface"""
+        data = []
+
+        # TODO: Parcourir les logs et instancier des objets Transceiver interface
+
+        self.config["transceiver_interface"] = data
+
+    def _parse_logbuffer(self):
+        """Parse display logbuffer"""
+        raw_table = []
+
+        # TODO: Parcourir les logs et instancier des objets Log
+
+        self.config["logbuffer"] = {
+            "raw_table": raw_table
+        }
+
+    def _parse_multicast(self):
+        """Parse display multicast forwarding-table"""
+        multicast = []
+        
+        # TODO: Parcourir les logs et instancier des objets Multicast
+
+        self.config["multicast"] = multicast
+
+    def _parse_qos(self):
+        """Parse qos policy user-defined"""
+        qos = []
+
+       # TODO: Parcourir les logs et instancier des objets QOS
+
+        self.config["qos"] = qos
+
+    def _parse_aaa(self):
+        """Parse dot1x"""
+        aaa = []
+
+        # TODO: Parcourir les logs et instancier des objets AAA
+
+        self.config["aaa"] = aaa
+
+    def _parse_stp(self):
+        """Parse display stp"""
+        stp = StpInfo()
+        
+        # TODO: Parcourir les logs et instancier des objets STP
+
+        self.config["stp"] = stp
+
+    def _parse_interface(self):
+        """Parse display interface"""
+        INTERFACE_NAME_RE = re.compile(
+            r'^('
+            r'Bridge-Aggregation\d+'
+            r'|HundredGigE[\d/]+'
+            r'|Ten-GigabitEthernet[\d/]+'
+            r'|GigabitEthernet[\d/]+'
+            r'|M-GigabitEthernet[\d/]+'
+            r'|FortyGigE[\d/]+'
+            r'|XGE[\d/]+'
+            r'|Vlan-interface\d+'
+            r'|LoopBack\d+'
+            r'|InLoopBack\d+'
+            r'|NULL\d+'
+            r'|Register-Tunnel\d+'
+            r'|Tunnel\d+'
+            r')$',
+            re.IGNORECASE
+        )
+        interfaces = []
+
+        # TODO: Parcourir les logs et instancier des objets Interface
+
+        self.config["interfaces"] = interfaces
+
+    def _parse_link_aggregation(self):
+        """Parse display link-aggregation verbose"""
+        aggs = []
+
+        # TODO: Parcourir les logs et instancier des objets Link Aggregation
+
+        self.config["link_aggregation"] = aggs
+
+    def _parse_current_configuration(self):
+        """Parse display current-configuration"""
+        self.config["current_configuration"] = self._parse_configuration_section(
+            "display current-configuration"
+        )
+
+    def _parse_saved_configuration(self):
+        """Parse display saved-configuration"""
+        self.config["saved_configuration"] = self._parse_configuration_section(
+            "display saved-configuration"
+        )
+    
+    def _parse_configuration_section(self, section_marker: str) -> DeviceConfiguration:
+        """Parse une section de configuration (current ou saved)"""
+        config = DeviceConfiguration()
+
+        # TODO: Parcourir les logs et instancier des objets Configuration
+
+        return config
+    
+
+    def parse_all(self):
+        """Parse tous les éléments de configuration"""
+        print("Début du parsing de la configuration MODELE...")
+        self.load_file()
+        self._parse_mac_address()
+        self._parse_arp_table()
+        self._parse_routing_table()
+        self._parse_fib_table()
+        self._parse_version()
+        self._parse_device_manuinfo()
+        self._parse_power()
+        self._parse_fan()
+        self._parse_environment()
+        self._bootloader_information()
+        self._parse_irf()
+        self._parse_irf_topology()
+        self._parse_irf_configuration()
+        self._parse_cpu_process()
+        self._parse_process()
+        self._parse_memory()
+        self._parse_transceiver_diagnosis()
+        self._parse_transceiver_interface()
+        self._parse_logbuffer()
+        self._parse_multicast() # Pas implémenté
+        self._parse_qos() # Pas implémenté
+        self._parse_aaa() # Pas implémenté
+        self._parse_stp()
+        self._parse_interface() 
+        self._parse_link_aggregation()
+        self._parse_current_configuration()
+        self._parse_saved_configuration()
+        # display poe interface (a voir si existe dans d'autres logs)
+        print("✓ Parsing terminé avec succès!")
+    
+    def export_to_json(self, output_file1: str, output_file2: str):
+        """Exporte la configuration au format JSON OpenConfig"""
+        fw_name = self.config['current_configuration'].hostname
+        openconfig_data_c = self.to_openconfig_yang("modele", fw_name, "current_configuration")
+        openconfig_data_s = self.to_openconfig_yang("modele", fw_name, "saved_configuration")
+        
+        with open(output_file1, "w", encoding="utf-8") as f:
+            json.dump(openconfig_data_c, f, indent=2, ensure_ascii=False)
+        
+        with open(output_file2, "w", encoding="utf-8") as f:
+            json.dump(openconfig_data_s, f, indent=2, ensure_ascii=False)
+        
+        print(f"✓ Configuration exportée vers: {output_file1} {output_file2}")
+    
+def generate_json_modele(input_file: str, output_file1: str, output_file2: str):
+    """Génère le fichier JSON OpenConfig à partir du fichier XML MODELE"""
+    file = Path(input_file)
+    if not file.exists():
+        print(f"✗ Erreur: Le fichier '{file}' n'existe pas")
+        return
+    
+    try:
+        parser = ModeleParser(str(file))
+        parser.parse_all()
+        parser.print_summary()
+        
+        parser.export_to_json(output_file1, output_file2)
+        print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file1} {output_file2}")
+        
+    except Exception as e:
+        print(f"✗ Erreur: {e}")
+        return
+```
+
+## Étape 2 : Intégration dans le moteur principal (`main.py`)
+
+Pour que le script global prenne en charge le nouveau modèle, ouvrez le fichier `Parseurs_logs_Switch/src/main.py` :
+
+1. Importez votre nouvelle fonction en haut du fichier :
+```python
+import scripts.json_modele as json_modele
+```
+
+2. Ajoutez la condition correspondante dans le bloc de sélection du type de firewall :
+```python
+elif switch_type == "modele":
+        json_modele.generate_json_modele(input_data, output_file1_json, output_file2_json)
+```
+
+3. Mettez à jour les instructions textuelles d'usage affichées dans la console si le paramètre saisi est incorrect afin d'inclure `"modele"` dans la liste des choix valides.
+
+
+## Étape 3 : Adaptation de l'Interface Graphique (GUI)
+
+Afin que le nouveau modèle apparaisse dans l'interface graphique unifiée :
+
+1. Ouvrez le fichier de gestion de la GUI (`gui_switch.py` racine ou script GUI dédié).
+2. Repérez le composant de sélection (Menu déroulant / ComboBox ou liste de boutons radio) listant les switches.
+3. Ajoutez **`MODELE`** à la liste des choix graphiques.
+
+> **Important :** faire attention si le script prend en compte un dossier ou un fichier.

Parseurs_config_Firewall/MODELE.md

@@ -0,0 +1,204 @@
+```json
+{
+  "firewall-device": {
+    "type": "", //palo-alto, forcepoint, stormshield
+    "name": [
+      "NOM_Switch"
+    ]
+  },
+  "openconfig-interfaces:interfaces": {
+    "interface": [
+      {
+        "name": "INTERFACE NAME",
+        "config": {
+          "name": "INTERFACE NAME",
+          "type": "", //iana-if-type:ieee8023adLag, iana-if-type:ethernetCsmacd, ...
+          "enabled": true,
+          "description": "DESCRIPTION"
+        },
+        "subinterfaces": {
+          "subinterface": [
+            {
+              "index": 0,
+              "config": {
+                "index": 0,
+                "enabled": true
+              },
+              "oc-ip:ipv4": {
+                "oc-ip:addresses": {
+                  "oc-ip:address": [
+                    {
+                      "oc-ip:ip": "IP",
+                      "oc-ip:config": {
+                        "oc-ip:ip": "IP",
+                        "oc-ip:prefix-length": "MASQUE"
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "openconfig-network-instance:network-instances": {
+    "network-instance": [
+      {
+        "name": "NOM",
+        "config": {
+          "name": "NOM",
+          "type": "TYPE"
+        },
+        "interfaces": {
+          "interface": [
+            {
+              "id": "" // INTERFACE
+            }
+          ]
+        },
+        "protocols": { //routing table
+          "protocol": [
+            {
+              "identifier": "STATIC",
+              "name": "STATIC",
+              "static-routes": {
+                "static": [
+                  {
+                    "prefix": "CIDR",
+                    "next-hops": {
+                      "next-hop": [
+                        {
+                          "index": "", //NAME
+                          "config": {
+                            "index": "", //NAME
+                            "next-hop": "", //NEXT VR ou NEXT HOP IP
+                            "metric": 10,
+                            "oc-loc-rt-netinst:next-network-instance": "", //NEXT VR si NEXT VR
+                            "oc-loc-rt-netinst:nh-network-instance": "" // NEXT HOP IP si NEXT HOP IP
+                          },
+                          "interface-ref": {
+                            "config": {
+                              "interface": "" // INTERFACE
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "openconfig-acl:acl": {
+    "acl-sets": {
+      "acl-set": [
+        {
+          "name": "NOM",
+          "type": "openconfig-acl:ACL_IPV4",
+          "config": {
+            "name": "NOM",
+            "type": "openconfig-acl:ACL_IPV4",
+            "description": "DESCRIPTION"
+          },
+          "state": {
+            "description": true
+          },
+          "acl-entries": {
+            "acl-entry": [
+              {
+                "sequence-id": 1,
+                "config": {
+                  "sequence-id": 1,
+                  "description": [ //application
+                    "ping",
+                  ]
+                },
+                "state": {
+                  "sequence-id": 1,
+                  "description": "" //Format "Misc: liste des tag member"
+                },
+                "ipv4": {
+                  "config": {
+                    "source-address": "any",
+                    "destination-address": "any"
+                  }
+                },
+                "transport": {
+                  "config": {
+                    "source-port": "any",
+                    "destination-port": "" //service member
+                  }
+                },
+                "actions": {
+                  "config": {
+                    "forwarding-action": "", //openconfig-acl:ACCEPT, openconfig-acl:ACCEPT_DISABLED, openconfig-acl:DROP, openconfig-acl:NAT
+                    "log-action": ""
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  },
+  "custom-firewall-objects:firewall-objects": {
+    "address": [
+      {
+        "name": "ADDRESS NAME",
+        "config": {
+          "name": "ADDRESS NAME",
+          "ip_netmask": "IP ou CIDR",
+          "description": "DESCRIPTION",
+          "misc": [] //tag member
+        }
+      }
+    ],
+    "address-group": [
+      {
+        "name": "ADDRESS GROUP NAME",
+        "config": {
+          "name": "GROUP NAME",
+          "members": [
+            "ADDRESS NAME"
+          ],
+          "description": "DESCRIPTION",
+          "misc": [] //tag member
+        }
+      }
+    ],
+    "service": [
+      {
+        "name": "SERVICE NAME",
+        "config": {
+          "name": "SERVICE NAME",
+          "protocol": "", //udp, tcp, ...
+          "port": "",
+          "source_port": "1",
+          "description": "DESCRIPTION",
+          "misc": [] //tag member
+        }
+      }
+    ],
+    "service-group": [
+      {
+        "name": "SERVICE GROUP NAME",
+        "config": {
+          "name": "SERVICE GROUP NAME",
+          "members": [
+            "SERVICE NAME"
+          ],
+          "description": "DESCRIPTION",
+          "misc": [] //tag member
+        }
+      }
+    ]
+  }
+}
+```

Parseurs_config_Firewall/README.md

@@ -4,8 +4,8 @@
 
 Cet outil permet de **parser les configurations de différents types de firewalls** (Palo Alto, Stormshield, Forcepoint) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.  
 
-Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
+- Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
-Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
+- Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
 
 ## Fonctionnalités principales
 

Parseurs_logs_Switch/MODELE.md

@@ -0,0 +1,781 @@
+```json
+{
+  "switch-device": {
+    "type": "hpe",
+    "name": "NOM_Switch"
+  },
+  "openconfig-system:system": {
+    "state": [
+      {
+        "hostname": "NOM_Switch",
+        "login-banner": [
+          "Message de",
+          "Connexion"
+        ],
+        "motd-banner": [
+          "Message de",
+          "Connexion"
+        ],
+        "current-datetime": "",
+        "up-time": "1 weeks, 1 days, 1 hours, 1 minutes",
+        "software-version": "Version 1 Release 1"
+      }
+    ],
+    "aaa": {
+      "authentication": {
+        "users": {
+          "user": [
+            {
+              "username": "user",
+              "config": {
+                "username": "user",
+                "password-hashed": "hash",
+                "role": "role",
+                "openconfig-system-ext:allowed-services": [
+                  "http"
+                ]
+              }
+            }
+          ]
+        }
+      }
+    },
+    "processes": {
+      "process": [
+        {
+          "pid": 1, // int de l'id du master
+          "state": {
+            "pid": 1, // int de l'id du master
+            "args": [
+              "cpu process master",
+              "liste des éléments",
+              "process master",
+              "liste des éléments"
+            ]
+          }
+        }
+      ]
+    },
+    "messages": {
+      "state": {
+        "message": [
+          {
+            "msg": "log" //string de tous les logs
+          }
+        ]
+      }
+    },
+    "ssh-server": {
+      "enabled": true,
+      "config": {
+        "enabled": true,
+        "openconfig-system-ext:access-permissible": "1"
+      }
+    },
+    "cpus": {
+      "cpu": [
+        {
+          "index": 1, // int de l'id du master
+          "state": {
+            "index": 1, // int de l'id du master
+            "instant": 0, // % CPU utilization in 5 secs
+            "min": 0, // % CPU utilization in 1 min
+            "max": 0 // % CPU utilization in 5 mins
+          }
+        }
+      ]
+    },
+    "ntp": {
+      "config": {
+        "enabled": true,
+        "ntp-source-address": "interface name"
+      },
+      "servers": {
+        "server": [
+          {
+            "address": "ip",
+            "config": {
+              "address": "ip",
+              "prefer": true
+            }
+          }
+        ]
+      },
+      "peers": {
+        "peer": [
+          {
+            "address": "ip",
+            "config": {
+              "address": "ip",
+              "prefer": true
+            }
+          }
+        ]
+      }
+    }
+  },
+  "openconfig-lldp:lldp": {
+    "config": {
+      "enabled": true
+    }
+  },
+  "openconfig-relay-agent:relay-agent": {
+    "dhcp": {
+      "config": {
+        "enable-relay-agent": true
+      }
+    }
+  },
+  "ietf-snmp:snmp": {
+    "ietf-snmp:snmp": {
+      "engine": {
+        "version": {
+          "v1": true,
+          "v2c": true,
+          "v3": true
+        },
+        "engine-id": "id"
+      },
+      "community": [
+        {
+          "index": 0,
+          "text-name": "mail@contact",
+          "context": "Contact: NOM Location: NOM" // Format Contact: NOM Location: NOM
+        }
+      ],
+      "usm": {
+        "local": {
+          "user": [
+            {
+              "name": "NOM UTILISATEUR",
+              "auth": {
+                "md5": {
+                  "key": "" //REDACTED si authentication mode
+                }
+              },
+              "priv": {
+                "aes": {
+                  "key": "" //REDACTED si privacy mode
+                }
+              }
+            }
+          ]
+        }
+      },
+      "vacm": {
+        "group": [
+          {
+            "name": "NOM GROUPE",
+            "access": [
+              {
+                "security-model": "", //V1, v2, v3
+                "notify-view": "",
+                "source-context": "", //id acl
+                "read-view": "All",
+                "write-view": "All",
+                "notify-view": "All"
+              }
+            ]
+          }
+        ],
+        "view": [ //mib view
+          {
+            "name": "All",
+            "include": [
+              "iso"
+            ],
+            "exclude": []
+          }
+        ]
+      },
+      "target": [ // target host
+        {
+          "name": "NOM TARGET",
+          "udp": {
+            "ip": "ip"
+          },
+          "target-params": "NOM PARAM"
+        }
+      ],
+      "target-params": [ // target param
+        {
+          "name": "NOM PARAM",
+          "usm": {
+            "user-name": "NOM TARGET",
+            "security-level": "auth-priv"
+          }
+        }
+      ]
+    }
+  },
+  "openconfig-interfaces:interfaces": {
+    "interface": [
+      {
+        "name": "NOM INTERFACE",
+        "config": {
+          "name": "NOM INTERFACE",
+          "type": "" // iana-if-type:ieee8023adLag si Bridge-Aggregation sinon null
+        },
+        "state": {
+          "name": "NOM INTERFACE",
+          "admin-status": "", //UP ou DOWN
+          "oper-status": "", // UP ou DOWN ou null
+          "description": "", // Format "Jumbo: True/False;Description: ...;Media: ...;Hardware: type de lien;Raw: config de l'interface dans current-configuration;Counters Cleared: date;
+          "mtu": null,
+          "counters": {
+            "in-octets": null,
+            "in-pkts": null,
+            "in-unicast-pkts": null,
+            "in-broadcast-pkts": null,
+            "in-multicast-pkts": null,
+            "in-pauses-pkts": null,
+            "in-drops": null,
+            "in-errors": null,
+            "out-octets": null,
+            "out-pkts": null,
+            "out-unicast-pkts": null,
+            "out-broadcast-pkts": null,
+            "out-multicast-pkts": null,
+            "out-pauses-pkts": null,
+            "out-drops": null,
+            "out-errors": [
+              {
+                "type": "output errors",
+                "count": 0
+              },
+              {
+                "type": "underruns",
+                "count": 0
+              },
+              {
+                "type": "buffer failures",
+                "count": 0
+              },
+              {
+                "type": "aborts",
+                "count": 0
+              },
+              {
+                "type": "deferred",
+                "count": 0
+              },
+              {
+                "type": "collisions",
+                "count": 0
+              },
+              {
+                "type": "late collisions",
+                "count": 0
+              },
+              {
+                "type": "lost carrier",
+                "count": 0
+              },
+              {
+                "type": "no carrier",
+                "count": 0
+              }
+            ]
+          },
+          "openconfig-if-aggregate-ext:load-sharing-type": "Shar"
+        },
+        "ethernet": {
+          "name": "Bridge-Aggregation1",
+          "state": {
+            "enable-flow-control": null,
+            "duplex-mode": "unknown-duplex",
+            "port-speed": null
+          },
+          "switched-vlan": {
+            "state": {
+              "interface-mode": "", //ACCESS ou TRUNK
+              "native-vlan": 1, // PVID
+              "access-vlan": 1, // si ACCESS: PVID
+              "trunk-vlans": [ // si TRUNK
+                "vlan_passing",
+                1,
+                "vlan_permitted",
+                1
+              ]
+            }
+          }
+        },
+        "subinterfaces": { 
+          "subinterface": [
+            {
+              "index": 0, //toujours 0
+              "config": {
+                "index": 0 //toujours 0
+              },
+              "state": {
+                "index": 0 //toujours 0
+              },
+              "oc-ip:ipv4": {
+                "oc-ip:neighbors": { // table arp
+                  "oc-ip:neighbor": [
+                    {
+                      "ip": "IP",
+                      "config": {
+                        "ip": "IP",
+                        "link-layer-address": "MAC"
+                      },
+                      "state": {
+                        "ip": "IP",
+                        "link-layer-address": "MAC",
+                        "origin": "DYNAMIC",
+                        "openconfig-if-ip-ext:aging": "",
+                        "openconfig-if-ip-ext:vlan": ""
+                      }
+                    }
+                  ]
+                },
+                "addresses": { // Internet address
+                  "address": [
+                    {
+                      "ip": "IP",
+                      "state": {
+                        "ip": "IP",
+                        "prefix-length": 255 // Masque
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        "openconfig-if-aggregate:aggregation": {
+          "state": {
+            "lag-type": "Static", //Static ou Dynamic
+            "member": [
+              "Local",
+              "texte",
+              "Remote",
+              "texte"
+            ]
+          }
+        }
+      }
+    ]
+  },
+  "openconfig-network-instance:network-instances": {
+    "network-instance": [
+      {
+        "name": "default",
+        "fdb": {
+          "mac-table": { // table mac
+            "entries": {
+              "entry": [
+                {
+                  "mac-address": "MAC",
+                  "vlan": "1",
+                  "config": {
+                    "mac-address": "MAC",
+                    "vlan": "1"
+                  },
+                  "state": {
+                    "mac-address": "MAC",
+                    "vlan": "1",
+                    "age": "Y", //aging
+                    "entry-type": "Learned" // State
+                  },
+                  "interface": {
+                    "interface-ref": {
+                      "config": {
+                        "interface": "NOM INTERFACE"
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
+        "protocols": { //table de routage
+          "protocol": [
+            {
+              "identifier": "", // oc-pol-types:RIP, oc-pol-types:DIRECT, oc-pol-types:STATIC, oc-pol-types:IPV4
+              "name": "", //RIP, DIRECT, STATIC, IPV4
+              "static-routes": {
+                "static": [
+                  {
+                    "prefix": "CIDR",
+                    "config": {
+                      "prefix": "CIDR"
+                    },
+                    "next-hops": {
+                      "next-hop": [
+                        {
+                          "index": 0,
+                          "config": {
+                            "next-hop": "IP",
+                            "metric": 0,
+                            "preference": 0
+                          },
+                          "interface-ref": {
+                            "config": {
+                              "interface": "INTERFACE"
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        "tables": { //table FIB
+          "table": [
+            {
+              "protocol": "oc-pol-types:IPV4",
+              "address-family": "oc-types:IPV4",
+              "ipv4": {
+                "routes": {
+                  "route": [
+                    {
+                      "prefix": "CIDR",
+                      "state": {
+                        "prefix": "CIDR",
+                        "active": true,
+                        "_custom_flags": "" //FLAG
+                      },
+                      "next-hops": {
+                        "next-hop": [
+                          {
+                            "index": 0,
+                            "state": {
+                              "next-hop": "IP",
+                              "pushed-mpls-label-stack": []
+                            },
+                            "interface-ref": {
+                              "state": {
+                                "interface": "INTERFACE"
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "openconfig-vlan:vlans": {
+    "vlan": [
+      {
+        "vlan-id": 1,
+        "config": {
+          "vlan-id": 1,
+          "name": "" //NAME
+        },
+        "state": {
+          "name": "" //DESCRIPTION
+        }
+      }
+    ]
+  },
+  "openconfig-acl:acl": {
+    "acl-sets": {
+      "acl-set": [
+        {
+          "name": "1", //numéro ACL
+          "type": "", //basic ou advanced
+          "config": {
+            "name": "1", //numéro ACL
+            "type": "", //basic ou advanced
+            "description": ""
+          },
+          "acl-entries": {
+            "acl-entry": [
+              {
+                "sequence-id": 1,
+                "config": {
+                  "sequence-id": 1,
+                  "forwarding-action": "" //ACCEPT ou DROP
+                },
+                "ipv4": {
+                  "config": {
+                    "protocol": "", //IP_TCP, UP_UDP, IP_PIM
+                    "source-address": "IP",
+                    "source-address-prefix-set": "MASQUE",
+                    "destination-address": "IP",
+                    "destination-address-prefix-set": "MASQUE"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  },
+  "openconfig-platform:components": {
+    "component": [
+      {
+        "name": "CHASSIS",
+        "config": {
+          "name": "CHASSIS"
+        },
+        "state": {
+          "name": "CHASSIS",
+          "type": "oc-platform-types:CHASSIS",
+          "model-name": ""
+        }
+      },
+      {
+        "name": "OS",
+        "config": {
+          "name": "OS"
+        },
+        "state": {
+          "name": "OS",
+          "type": "oc-platform-types:OPERATING_SYSTEM",
+          "description": "", //Format "Boot-image: ..."
+          "software-version": "Version 1 Release 1"
+        }
+      },
+      {
+        "name": "Switch 1",
+        "config": {
+          "name": "Switch 1"
+        },
+        "state": {
+          "name": "Switch 1",
+          "type": "oc-platform-types:LINECARD",
+          "id": 1,
+          "description": "", //Format "Patch version: ..."
+          "hardware-version": "", // release version
+          "software-version": "", //Format "CURRENT: ... | MAIN: ... | BACKUP: ..."
+          "model-name": "", //board type
+          "last-reboot-reason": "",
+          "redundant-role": "", //Standby ou Master
+          "memory": {
+            "available": 1,
+            "utilized": 1
+          }
+        },
+        "properties": {
+          "property": [
+            {
+              "name": "irf-priority",
+              "state": {
+                "name": "irf-priority",
+                "value": "1" //priority
+              }
+            },
+            {
+              "name": "irf-link-1",
+              "state": {
+                "name": "irf-link-1",
+                "value": "Neighbor: 2 | State: UP"
+              }
+            },
+            {
+              "name": "irf-link-2",
+              "state": {
+                "name": "irf-link-2",
+                "value": "Neighbor: 3 | State: UP"
+              }
+            },
+            {
+              "name": "irf-config-port1",
+              "state": {
+                "name": "irf-config-port1",
+                "value": "Ten-GigabitEthernet1/0/1, Ten-GigabitEthernet1/0/2"
+              }
+            },
+            {
+              "name": "irf-config-port2",
+              "state": {
+                "name": "irf-config-port2",
+                "value": "Ten-GigabitEthernet1/0/3, Ten-GigabitEthernet1/0/4"
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": "CPU 1",
+        "config": {
+          "name": "CPU 1"
+        },
+        "state": {
+          "name": "CPU 1",
+          "type": "oc-platform-types:LINECARD",
+          "description": "", //DEVICE NAME
+          "mfg-name": "", // VENDOR NAME
+          "mfg-date": "", // MANUFACTURING DATE
+          "serial-no": "", //SN
+          "part-no": "", //PRODUCT NUMBER
+          "base-mac-address": "MAC"
+        }
+      },
+      {
+        "name": "FAN 1",
+        "config": {
+          "name": "FAN 1"
+        },
+        "state": {
+          "name": "FAN 1",
+          "type": "oc-platform-types:FAN",
+          "description": "", //DEVICE NAME
+          "mfg-name": "", // VENDOR NAME
+          "mfg-date": "", // MANUFACTURING DATE
+          "serial-no": "", //SN
+          "parent": "CPU 1",
+          "oper-status": "" //STATE
+        },
+        "openconfig-platform-fan:fan": {
+          "state": {
+            "oc-fan:airflow-direction": "",
+            "oc-fan:prefer-airflow-direction": ""
+          }
+        }
+      },
+      {
+        "name": "POWER 1",
+        "config": {
+          "name": "POWER 1"
+        },
+        "state": {
+          "name": "POWER 1",
+          "type": "oc-platform-types:POWER_SUPPLY",
+          "description": "", //DEVICE NAME
+          "mfg-name": "", // VENDOR NAME
+          "mfg-date": "", // MANUFACTURING DATE
+          "serial-no": "", //SN
+          "parent": "CPU 1",
+          "oper-status": "" //STATE
+        },
+        "openconfig-platform-psu:power-supply": {
+          "state": {
+            "oc-platform-psu:mode": ""
+          }
+        }
+      },
+      {
+        "name": "hotspot 1",
+        "config": {
+          "name": "hotspot 1"
+        },
+        "state": {
+          "name": "hotspot 1",
+          "type": "oc-platform-types:SENSOR",
+          "parent": 1, //SLOT
+          "temperature": {
+            "instant": "1"
+          }
+        }
+      },
+      { //transceiver diagnostic et interface
+        "name": "INTERFACE NAME",
+        "config": {
+          "name": "INTERFACE NAME"
+        },
+        "state": {
+          "name": "INTERFACE NAME",
+          "type": "oc-platform-types:TRANSCEIVER",
+          "present": "", //PRESENT ou null
+          "form-factor": "", //TRANSCEIVER TYPE
+          "connector-type": "", 
+          "vendor": "",
+          "part-no": "", //PRODUCT NUMBER/ORDERING NAME
+          "temperature": {
+            "instant": 1
+          }
+        },
+        "properties": {
+          "property": [
+            {
+              "name": "wavelength",
+              "state": {
+                "name": "wavelength",
+                "value": "1"
+              }
+            }
+          ]
+        },
+        "oc-transceiver:transceiver": {
+          "state": {
+            "supply-voltage": {
+              "instant": 1 //VOLTAGE
+            },
+            "output-power": {
+              "instant": 1 //TX
+            },
+            "input-power": {
+              "instant": 1 //RX
+            },
+            "laser-bias-current": {
+              "instant": 1 //BIAS
+            }
+          }
+        }
+      }
+    ]
+  },
+  "openconfig-spanning-tree:stp": {
+    "global": {
+      "state": {
+        "enabled-protocol": [
+          "oc-stp-types:RSTP"
+        ],
+        "bpdu-guard": false
+      }
+    },
+    "interfaces": {
+      "interface": [
+        {
+          "name": "INTERFACE NAME",
+          "state": {
+            "hello-time": "",
+            "name": "INTERFACE NAME",
+            "edge-port": "",
+            "bpdu-mst": "",
+            "rapid-transition": "", //True ou False
+            "num-vlans": 1
+          }
+        }
+      ]
+    },
+    "rstp": {
+      "state": {
+        "hello-time": "",
+        "bridge-priority": "0",
+        "bridge-address": "MAC",
+        "designated-root-address": "MAC",
+        "root-port": "0",
+        "topology-changes": 1,
+        "last-topology-change": "DATE"
+      },
+      "interfaces": {
+        "interface": [
+          {
+            "name": "INTERFACE NAME",
+            "state": {
+              "name": "INTERFACE NAME",
+              "port-num": 1,
+              "protocol": "", //Enabled ou Disabled
+              "role": "",
+              "port-state": "", //UP ou DOWN
+              "counters": {
+                "state": {
+                  "bpdu-sent": 1,
+                  "bpdu-received": 1
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}
+```

Parseurs_logs_Switch/README.md

@@ -4,10 +4,10 @@
 
 Cet outil permet de **récupérer les données des logs de différents types de switches** (HPE uniquement actuellement) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.  
 
-Il fournit également la possibilité de générer une **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
+- Il fournit également la possibilité de générer un **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
-Il fournit également la possibilité de générer une **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
+- Il fournit également la possibilité de générer un **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
-Il fournit également la possibilité de générer une **rapport des stack format Excel** pour visualiser les stack de chaque switch.
+- Il fournit également la possibilité de générer un **rapport des stack format Excel** pour visualiser les stack de chaque switch.
-Il founit également la possibilité de générer une **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
+- Il founit également la possibilité de générer un **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
 
 ## Fonctionnalités principales
 

Parseurs_logs_Switch/src/main.py

@@ -0,0 +1,127 @@
+import sys
+import os
+import time
+import scripts.json_hpe as json_hpe
+from pathlib import Path
+from scripts.export_schema_infra import main as schema_infra
+from scripts.export_rapport_uplink import main as rapport_uplink
+from scripts.export_rapport_stack import main as rapport_stack
+from scripts.export_rapport_interfaces import main as rapport_interfaces
+
+sys.path.append(os.path.dirname(__file__))
+
+def verify_if_file_exists(name):
+    base, ext = os.path.splitext(name)
+    counter = 1
+    new_name = name
+    while os.path.exists(new_name):
+        new_name = f"{base}_{counter}{ext}"
+        counter += 1
+    return new_name
+
+def main():
+    """Fonction principale du programme d'analyse de switches"""
+    if len(sys.argv) < 3:
+        print("Usage: python3 src/main.py <switch_type>[hpe|...] <input_file> [-o <output_file>] [-u] [-d] [-s] [-i]")
+        print("Options:")
+        print("  <switch_type>      Type of switch to process (hpe)")
+        print("  -o <output_file>   Specify output JSON file name (optional)")
+        print("  -d                 Generate infrastructure schema (optional)")
+        print("  -u                 Generate uplink report (optional)")
+        print("  -s                 Generate stack report (optional)")
+        print("  -i                 Generate interface report (optional)")
+        sys.exit(1)
+
+    switch_type = sys.argv[1].lower()
+    input_data = sys.argv[2]
+    input_path = "src/input/"
+    output_path = "src/output/"
+    os.makedirs(output_path, exist_ok=True)
+
+    if "-o" in sys.argv:
+        o_index = sys.argv.index("-o")
+        if o_index + 1 < len(sys.argv):
+            output_file1_json = f"{output_path}{switch_type}_saved_{sys.argv[o_index + 1]}.json"
+            output_file2_json = f"{output_path}{switch_type}_current_{sys.argv[o_index + 1]}.json"
+        else:
+            print("Erreur: nom de fichier de sortie manquant après '-o'.")
+            sys.exit(1)
+    else:
+        timestamp = time.strftime("%Y%m%d")
+        output_file1_json = f"{output_path}{switch_type}_current_{timestamp}.json"
+        output_file2_json = f"{output_path}{switch_type}_saved_{timestamp}.json"
+    output_file1_json = verify_if_file_exists(output_file1_json)
+    output_file2_json = verify_if_file_exists(output_file2_json)
+
+    if switch_type == "hpe":
+        json_hpe.generate_json_hpe(input_data, output_file1_json, output_file2_json)
+    else:
+        print("Erreur: type de switch inconnu. Utilisez 'hpe'.")
+        sys.exit(1)
+
+    if "-d" in sys.argv:
+        print(f"\nGénération du schéma d'infrastructure...")
+        if "-o" in sys.argv:
+            o_index = sys.argv.index("-o")
+            if o_index + 1 < len(sys.argv):
+                output_file_html = os.path.join(f"{output_path}schema_infra_{switch_type}_{sys.argv[o_index + 1]}.html")
+            else:
+                print("Erreur: nom de fichier de sortie manquant après '-o'.")
+                sys.exit(1)
+        else:
+            timestamp = time.strftime("%Y%m%d")
+            output_file_html = f"{output_path}schema_infra_{switch_type}_{timestamp}.html"
+        output_file_html = verify_if_file_exists(output_file_html)
+        html_file = schema_infra(output_path, output_file_html)
+        print(f"✓ Processus terminé. Fichiers générés:\n   - JSON: {output_file1_json} & {output_file2_json}\n   - HTML: {html_file}")
+
+    if "-u" in sys.argv:
+        print(f"\nGénération du rapport d'uplink...")
+        if "-o" in sys.argv:
+            o_index = sys.argv.index("-o")
+            if o_index + 1 < len(sys.argv):
+                output_file_excel = os.path.join(f"{output_path}rapport_uplink_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
+            else:
+                print("Erreur: nom de fichier de sortie manquant après '-o'.")
+                sys.exit(1)
+        else:
+            timestamp = time.strftime("%Y%m%d")
+            output_file_excel = f"{output_path}rapport_uplink_{switch_type}_{timestamp}.xlsx"
+        output_file_excel = verify_if_file_exists(output_file_excel)
+        excel_file = rapport_uplink(output_path, output_file_excel)
+        print(f"✓ Processus terminé. Fichiers générés:\n   - JSON: {output_file1_json} & {output_file2_json}\n   - Excel: {excel_file}")
+
+    if "-s" in sys.argv:
+        print(f"\nGénération du rapport de stack...")
+        if "-o" in sys.argv:
+            o_index = sys.argv.index("-o")
+            if o_index + 1 < len(sys.argv):
+                output_file_excel = os.path.join(f"{output_path}rapport_stack_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
+            else:
+                print("Erreur: nom de fichier de sortie manquant après '-o'.")
+                sys.exit(1)
+        else:
+            timestamp = time.strftime("%Y%m%d")
+            output_file_excel = f"{output_path}rapport_stack_{switch_type}_{timestamp}.xlsx"
+        output_file_excel = verify_if_file_exists(output_file_excel)
+        excel_file = rapport_stack(output_path, output_file_excel)
+        print(f"✓ Processus terminé. Fichiers générés:\n   - JSON: {output_file1_json} & {output_file2_json}\n   - Excel: {excel_file}")
+
+    if "-i" in sys.argv:
+        print(f"\nGénération du rapport d'interfaces...")
+        if "-o" in sys.argv:
+            o_index = sys.argv.index("-o")
+            if o_index + 1 < len(sys.argv):
+                output_file_excel = os.path.join(f"{output_path}rapport_interfaces_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
+            else:
+                print("Erreur: nom de fichier de sortie manquant après '-o'.")
+                sys.exit(1)
+        else:
+            timestamp = time.strftime("%Y%m%d")
+            output_file_excel = f"{output_path}rapport_interfaces_{switch_type}_{timestamp}.xlsx"
+        output_file_excel = verify_if_file_exists(output_file_excel)
+        excel_file = rapport_interfaces(output_path, output_file_excel)
+        print(f"✓ Processus terminé. Fichiers générés:\n   - JSON: {output_file1_json} & {output_file2_json}\n   - Excel: {excel_file}")
+
+if __name__ == "__main__":
+    main()

Parseurs_logs_Switch/src/scripts/export_modele.py

@@ -181,7 +181,7 @@ class ParserMixin:
             "software-version": f"Version {self.config['version'].version if self.config['version'].version else None} Release {self.config['version'].release if self.config['version'].release else None}"
         })
 
-        # Conversion current configuration/saved configuration TODO
+        # Conversion current configuration/saved configuration
         # Users
         if self.config[config_type].local_users:
             oc_users = []

Parseurs_logs_Switch/src/scripts/json_hpe.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Parser pour configuration switch HPE vers un format json normalisé OpenConfig YANG
-Extrait les différentes sections de la configuration HPE et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
+Extrait les différentes sections de logs et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
 """
 
 import json
@@ -14,7 +14,7 @@ class HpeParser(ParserMixin):
     """Parser pour fichier XML HPE"""
     
     def __init__(self, file_path: str):
-        """Initialise le parser avec le chemin du fichier de configuration HPE"""
+        """Initialise le parser avec le chemin du fichier de logs HPE"""
         self.file = file_path
         self.root = None
         self.raw_data = None
@@ -1505,33 +1505,4 @@ def generate_json_hpe(input_file: str, output_file1: str, output_file2: str):
         
     except Exception as e:
         print(f"✗ Erreur: {e}")
-        return
+        return
-
-# if __name__ == "__main__":
-#     import sys
-    
-#     if len(sys.argv) != 2:
-#         print("Usage: python json_hpe.py <fichier_config>")
-#         print("Exemple: python json_hpe.py config_hpe")
-#         sys.exit(1)
-    
-#     file = sys.argv[1]
-    
-#     if not Path(file).exists():
-#         print(f"✗ Erreur: Le fichier '{file}' n'existe pas")
-#         sys.exit(1)
-    
-#     try:
-#         parser = HpeParser(file)
-#         parser.parse_all()
-#         parser.print_summary()
-        
-#         input_path = Path(file)
-#         output_file = 'output_Hpe.json'
-#         parser.export_to_json(output_file)
-        
-#         print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
-        
-#     except Exception as e:
-#         print(f"✗ Erreur: {e}")
-#         sys.exit(1)

README.md

@@ -0,0 +1,55 @@
+# Analyse Réseau
+
+## Description
+
+Cet outil centralisé permet de récupérer et d'analyser les données de configuration et de logs issues de différents équipements réseau (Firewalls et Switches). Il convertit ces informations brutes en un format JSON normalisé basé sur les modèles OpenConfig (YANG) et génère divers rapports d'infrastructure au format Excel ainsi que des schémas visuels.
+
+L'application dispose d'une interface graphique (GUI) qui automatise la gestion de l'environnement virtuel et l'installation des dépendances pour faciliter son utilisation.
+
+## Fonctionnalités par module
+
+- Module Firewall
+```bash
+Équipements supportés : Palo Alto, Stormshield, Forcepoint.
+Données extraites : Fichiers et dossiers de configurations d'origine.
+Rapports générés :
+- Matrice de flux (Excel) pour visualiser les communications et les règles de trafic.
+- Matrice de routage (Excel) pour cartographier les routes statiques.
+```
+
+- Module Switch
+```bash
+Équipements supportés : HPE (Comware / ProCurve).
+Données extraites : Fichiers de logs (outputs de commandes de diagnostic).
+Rapports générés :
+- Rapport des liens inter-switches (Excel).
+- Rapport des interfaces et de leurs compteurs (Excel).
+- Rapport d'état des stacks (Excel).
+- Schéma global de l'infrastructure réseau (génération visuelle des interconnexions).
+```
+
+## Avertissements (Pré-requis)
+
+Avant de lancer l'application, vous devez impérativement créer manuellement les dossiers input/ s'ils n'existent pas encore, et y déposer vos fichiers selon l'architecture suivante :
+
+- Pour le **Firewall** : Créer le dossier et déposer les configurations dans /Parseurs_config_Firewall/src/input/
+
+- Pour le **Switch** : Créer le dossier et déposer les fichiers de logs dans /Parseurs_logs_Switch/src/input/
+
+Fichier de site : N'oubliez pas de renseigner ou modifier le fichier de données site.json pour correspondre à vos zone réseau situé dans le dossier /Parseurs_config_Firewall/src/data/.
+
+## Utilisation & Interface Graphique
+L'outil intègre une interface graphique. Lors de son premier lancement, le script se charge de créer automatiquement un environnement virtuel (venv) et d'y installer tous les paquets requis (requirements.txt).
+
+Pour démarrer l'application, exécutez simplement la commande suivante à la racine du projet :
+
+```bash
+python3 ./main.py
+```
+
+## Gestion des Sorties (Output)
+Une fois l'analyse terminée, l'ensemble des données extraites (JSON OpenConfig, matrices Excel, rapports et schémas d'infrastructure) sera automatiquement exporté dans les répertoires output/ de leurs sections respectives :
+
+- Résultats Firewalls : /Parseurs_config_Firewall/src/output/
+
+- Résultats Switches : /Parseurs_logs_Switch/src/output/

help_Firewall.md

@@ -4,8 +4,8 @@
 
 Cet outil permet de **récupérer les données des configurations de différents types de firewalls** (Palo Alto, Stormshield, Forcepoint) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.  
 
-Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
+- Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
-Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
+- Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
 
 ## Utilisation
 

help_Switch.md

@@ -4,14 +4,16 @@
 
 Cet outil permet de **récupérer les données des logs de différents types de switches** (HPE uniquement actuellement) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.  
 
-Il fournit également la possibilité de générer une **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
+- Il fournit également la possibilité de générer un **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
-Il founit également la possibilité de générer une **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
+- Il fournit également la possibilité de générer un **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
+- Il fournit également la possibilité de générer un **rapport des stack format Excel** pour visualiser les stack de chaque switch.
+- Il founit également la possibilité de générer un **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
 
 ## Utilisation
 
 ### Pré-requis
 
-- Mettre le/les fichier(s) et/ou dossier(s) de configurations dans le dossier `/Parseurs_logs_Switch/src/input/`
+- Mettre le/les fichier(s) de logs dans le dossier `/Parseurs_logs_Switch/src/input/`
 
 ```bash
 python3 ./main.py