< Projet src="Artemis" />

La chasse aux informations

Artemis

Au Génoscope, nous utilisions 2 logiciels de sauvegarde : NetWorker et SnapVault. Pour des raisons financières, il a été décidé de remplacer NetWorker par NetBackup. Je vais donc, dans un premier temps, devoir repérer tous les volumes, qtree, etc... sauvegardés (ou pas) de notre infrastructure. Et, si un volume est sauvegardé, être capable de dire avec quoi et où. Puis, dans un second temps, lister la totalité des vieilles bandes de stockage "écrites" avec NetWorker et transferer toutes les données se trouvant sur chacune d'elles pour les réécrire avec NetBackup (notre nouveau logiciel). Le script qui va suivre permet d'accomplir la première étape et, aussi, de permettre une "supervision" d'absolument tous les volumes et tous les backups.



#!/bin/sh

#Yoann BAUMERT

# Création de la base

echo "drop database Artemis" | msql -uadmin -sSRV_MySQL Artemis
echo "source ~baumert/Artemis/Artemis.sql" | msql -uadmin -sSRV_MySQL
								
La partie de code ci-dessus permet simplement de supprimer la base de données avant de la recréer. Cela permet de "repartir à 0", d'être sûr que les anciennes données n'interfèrent pas avec les nouvelles. Le script est dans le cron afin de l'exécuter chaque jour. (Cron est un programme qui permet aux utilisateurs des systèmes Unix d’exécuter automatiquement des scripts, des commandes ou des logiciels à une date et une heure spécifiées à l’avance, ou selon un cycle défini à l’avance.)



#Remplir la table FSTAB à partir de la FSTAB de srv_backup.genoscope.com

ssh root@srv_backup.genoscope.com "cat /etc/fstab" |
  grep -v "#" |
  sed 's/:/\t/g' |
  sed 's/\t/;/g' |
  cut -d ';' -f 1,2,3 |
  sed 's/;/\t/g' |
  while read server volume path ; 
    do echo "INSERT INTO MDB_FSTAB (fstab_server,fstab_volume,fstab_path) VALUES(\"$server\",\"$volume\",\"$path\");" ;
    done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "FSTAB : OK"
								

Cette partie là, comme le dit le commentaire, va aller chercher des informations dans la FSTAB. La FSTAB contient le tableau répertoriant les différents systèmes de fichiers. Ce fichier contient une liste des disques utilisés au démarrage ainsi que leurs partitions.

Pourquoi as-tu besoin de ces infos ?

Avant tout, nous utilisons ce que nous appelons le "Netapp".

Qu'est-ce que c'est ? Nous avons plein de baies de disques durs (notre stockage se mesure en Petas Octets). Ces baies sont gérées par des controleurs avec une couche logicielle. C'est cette couche logicielle que je vais interroger pour extraire des informations indispensables pour la construction de ma base. Et c'est cette même couche que j'appelle le "Netapp" (puisque tout cet ensemble est vendu par l'entreprise Netapp :)

J'ai rencontré plusieurs obstacles. Le fameux Netapp utilise des "junction path" afin de "grouper" les volumes et les qtree dans un nombre réduits de lignes dans la FSTAB et ainsi faciliter le travail de l'administrateur... pour mon plus grand malheur. Par exemple : /etc/projets/projetA, /etc/projets/ProjetB, /etc/projets/ProjetC, /etc/projets/ProjetD se trouvent tous dans /etc/projets. Leurs junction path sera donc /etc/projets... oui mais... moi je cherche leur localisation exacte ! Je veux TOUT le path et non pas seulement ce junction path...

Pour couronner le tout, le junction path est choisi par l'administrateur... comment je peux être sûr que mon path ne contient pas une faute de frappe ? Comment automatiser tout ça si les path sont écrit par des humains ? Je suis donc allé voir dans la FSTAB qui répertorie chaque junction path avec chaque path réel par exemple :

/ce/junction/path/là/ => /se/trouve/en/réalité/ici/ (évidemment je simplifie :)

Les liens symboliques peuvent être totalement différents des chemins réels !

Bref, et j'ai donc du faire plusieurs comparaisons (via des commandes SQL qui viendront plus tard). Pour l'instant, je me contente de lire ce qui se trouve dans la FSTAB et de répertorier les informations intéressantes (tous les junction path avec tous les path réel) dans une base de données à coup de commandes grep (permet de cibler les données dans un fichier) de commandes sed (permet de remplacer des caractères par d'autres) de commandes cut (permet de couper les informations et de supprimer le superflu) le tout mit dans une boucle while qui va tourner jusqu'à ce que toutes les informations de la FSTAB soient traitées !

D'un point de vue un peu plus technique, ce "gros ensemble de commandes" (et comme tous les suivants) est du parsing (je reçois une réponse quelconque, je trie les données et ne garde que ce qui m'intéresse) Ce qui m'intéresse dans la réponse tirée de la FSTAB est : pour chaque ligne : un nom de serveur que l'on mettra dans la variable $server ; un nom de volume dans la variable $volume ; un path dans la variable $path le tout formalisé en requête SQL, pour l'envoyer directement dans ma base ! La syntaxe de la réponse doit être très exactement :

INSERT INTO MDB_FSTAB (fstab_server,fstab_volume,fstab_path) VALUES ("Le_Serveur_Du_Volume", "Mon_Volume", "/path/de/mon/volume");

Pour que la commande soit acceptée par MySQL. La difficulté est de respecter, en faisant de la concaténation en shell, la syntaxe des commandes SQL.


#Remplir la table DNS à partir du DNS de SRV_DNS

for i in `echo "SELECT DISTINCT fstab_server FROM MDB_FSTAB;" |msql -uadmin -sSRV_MySQL Artemis |sed s/\.genoscope\.com//g | sed s/\.seq\.com\.fr//g |sed s/\.com\.fr//g |cut -f 1`
  do
    ssh SRV_DNS.genoscope.com "cat /etc/puppet/dns/genoscope.com.edit" |
      grep $i |
      sed 's/\t/;/g' |
      sed 's/;;/;/g' |
      cut -d ';' -f 1,4 |
      sed 's/;/\t/g' |
      while read servername ipserver ;
        do echo "INSERT INTO MDB_DNS (dns_nom,dns_ip) VALUES (\"$servername\",\"$ipserver\");" ;
        done done |
msql -uadmin -sSRV_MySQL Artemis

echo "DNS : OK"
								

Par prévention, on est également allé chercher, dans puppet, le fichier qui stocke tous les enregistrments DNS (qui fait le lien entre un nom et une IP). Pour nous permettre de récupérer l'@ IP liée à tel nom de serveur. Toujours avec la même méthode de parsing. La commande doit me retourner un nom de serveur ainsi qu'une adresse IP :

INSERT INTO MDB_FSTAB (dns_nom,dns_ip) VALUES ("SERVEUR_TEST", "198.147.24.23");



#Remplir la table NBU à partir du script de Claude : ~baumert/NBU/scripts/content_policies2.sh

ssh srv_backup.genoscope.com "sh ~baumert/NBU/scripts/content_policies2.sh" |
  sed 's/\\/\\\\\\\\/g' |
  while read policy jpath space ;
    do echo "INSERT INTO MDB_NBU (nbu_policy_name,nbu_jpath) VALUES (\"$policy\",\"$jpath\");" ;
  done |
  grep -v '\"\"' |
msql -uadmin -sSRV_MySQL Artemis

echo "NBU : OK"
								

Ma tutrice, Claude, a réalisé un script qui récupère le nom de ce qu'on appelle "la policy" traduit en français non pas par "police" mais par "politique" ainsi qu'un path.

Qu'est-ce donc qu'une policy ?

Pour les informaticiens adeptes de Windows, je pourrais comparer ça (même si c'est assez maladroit) avec des OU (Organisation Unit) MAIS ! Dans ces "OU", on n'y range pas des utilisateurs, des ordinateurs ou des groupes mais des volumes/Qtree à sauvegarder !

Pour les non-informaticiens, ces policy sont des "boîtes" ou l'on va ranger les différents volumes à sauvegarder. Chaque policy aura une méthode de sauvegarde différente ! (Bah oui ! Sinon autant tout mettre dans la même :) On va coller une sorte d'étiquette sur chacunes de ces boîtes en disant "Cette boîte là sauvegarde tel ou tel volume(s) tel jour à tel heure et place les sauvegardes à tel endroit."

On récupère donc ce path et cette policy et on les insère dans la base, une requête qui doit ressembler à ça :

INSERT INTO MDB_FSTAB (nbu_policy_name,nbu_jpath) VALUES ("MA_POLICY", "/path/de/sauvegarde/de/ma/policy");



#Remplir la table CLUSTER à partir des infos du cluster netapp
#net int show -fields vserver,lif,address

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv1.local "net int show -fields vserver,lif,address" |
  tail -n +5 |grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g'|
  while read vserver lif ip space ;
    do echo "INSERT INTO MDB_CLUSTERS(clu_vserver,clu_lif,clu_ip) VALUES(\"$vserver\",\"$lif\",\"$ip\");" ;
    done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "CLUSTER : 1/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv2.local "net int show -fields vserver,lif,address" |
  tail -n +5 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g'|
  while read vserver lif ip space ;
    do echo "INSERT INTO MDB_CLUSTERS(clu_vserver,clu_lif,clu_ip) VALUES(\"$vserver\",\"$lif\",\"$ip\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "CLUSTER : 2/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv_snap.local "net int show -fields vserver,lif,address" |
  tail -n +5 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g'|
  while read vserver lif ip space ;
    do echo "INSERT INTO MDB_CLUSTERS(clu_vserver,clu_lif,clu_ip) VALUES(\"$vserver\",\"$lif\",\"$ip\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "CLUSTER : 3/3 : OK"
								
3 commandes d'un coup ?

Eeeeet oui ! Ce sont les mêmes commandes qui attaquent différents serveurs. Passons à l'explication : J'envoie une commande "Netapp" via le protocole SSH : net int show -fields vserver,lif,address afin de récupérer des informations du Netapp : précisément je veux chaque vserver avec son lif (interface réseau virtuelle) et l'adresse qui lui correspond afin de pouvoir, dans le futur, faire des correspondance entre l'adresse IP récupérée dans le fichier DNS (récupéré un peu plus haut) et l'adresse IP venant de cette commande Netapp :)

INSERT INTO MDB_FSTAB (clu_vserver,clu_lif,clu_ip) VALUES ("V_SERVEUR", "MA_LIF", "198.147.24.23");



#Remplir la table QTREE à partir des infos du cluster netapp
#qtree show -fields qtree-path,security-style

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv1.local "qtree show -fields qtree-path,security-style" |
  tail -n +3 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtreepath style space ;
    do echo "INSERT INTO MDB_QTREE(qtree_vserver, qtree_volume, qtree_qtree, qtree_path, qtree_style) VALUES(\"$vserver\",\"$volume\",\"$qtree\",\"$qtreepath\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE : 1/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv2.local "qtree show -fields qtree-path,security-style" |
  tail -n +3 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtreepath style space ;
    do echo "INSERT INTO MDB_QTREE(qtree_vserver, qtree_volume, qtree_qtree, qtree_path, qtree_style) VALUES(\"$vserver\",\"$volume\",\"$qtree\",\"$qtreepath\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE : 2/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv_snap.local "qtree show -fields qtree-path,security-style" |
  tail -n +3 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtreepath style space ;
    do echo "INSERT INTO MDB_QTREE(qtree_vserver, qtree_volume, qtree_qtree, qtree_path, qtree_style) VALUES(\"$vserver\",\"$volume\",\"$qtree\",\"$qtreepath\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE : 3/3 : OK"
								

Cette commande sert à lister les Qtrees de chacun des serveurs Netapp, avec le volume qui les contient, le serveur auquel ils appartiennent, leur nom (évidemment :3) et leur style ! (Style = UNIX ou NTFS etc...)

INSERT INTO MDB_QTREE(qtree_vserver, qtree_volume, qtree_qtree, qtree_path, qtree_style) VALUES("srv_test","volume_34","volume34_qtree34","/junction/path/volume34/qtree34","NTFS");



#Remplir la table VOLUME à partir des infos du cluster netapp
#volume show -fields junction-path,security-style

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv1.local "volume show -fields junction-path,security-style" |
  tail -n +3 |grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume style junction space ;
    do echo "INSERT INTO MDB_VOLUME(vol_vserver, vol_volume,vol_junction_path, vol_style) VALUES(\"$vserver\",\"$volume\",\"$junction\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "VOLUME : 1/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv2.local "volume show -fields junction-path,security-style" |
  tail -n +3 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume style junction space ;
    do echo "INSERT INTO MDB_VOLUME(vol_vserver, vol_volume,vol_junction_path, vol_style) VALUES(\"$vserver\",\"$volume\",\"$junction\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "VOLUME : 2/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv_snap.local "volume show -fields junction-path,security-style" |
  tail -n +3 |
  grep -v "displayed" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume style junction space ;
    do echo "INSERT INTO MDB_VOLUME(vol_vserver, vol_volume,vol_junction_path, vol_style) VALUES(\"$vserver\",\"$volume\",\"$junction\",\"$style\");" ;
  done |
  grep -v \"\" |
msql -uadmin -sSRV_MySQL Artemis

echo "VOLUME : 3/3 : OK"

								

Cette commande (envoyée également sur trois serveurs) va chercher tous les volumes répertoriés sur chaque serveur Netapp. volume show -fields junction-path,security-style On va ainsi, insérer chaque volume dans MDB_VOLUME avec le serveur auquel ils appartiennent, le junction path et leur style (pareil que les Qtrees : UNIX / NTFS etc...) ! Cette table nous servira de base pour le rapport généré plus tard.

INSERT INTO MDB_VOLUME(vol_vserver, vol_volume,vol_junction_path, vol_style) VALUES("srv_test","volume_34","/junction/path/volume34","NTFS");



#qtree show -fields qtree-path,security-style

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv1.local "qtree show -fields qtree-path,security-style" |
  grep \"\" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtree_path style ;
    do echo "UPDATE MDB_VOLUME SET vol_qtree_path=\"$qtree_path\" WHERE vol_vserver=\"$vserver\" AND vol_volume=\"$volume\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE-PATH : 1/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv2.local "qtree show -fields qtree-path,security-style" |
  grep \"\" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtree_path style ;
    do echo "UPDATE MDB_VOLUME SET vol_qtree_path=\"$qtree_path\" WHERE vol_vserver=\"$vserver\" AND vol_volume=\"$volume\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE-PATH : 2/3"

sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv_snap.local "qtree show -fields qtree-path,security-style" |
  grep \"\" |
  sed -r 's/^ *//;s/ {1,}/\t/g' |
  while read vserver volume qtree qtree_path style ;
    do echo "UPDATE MDB_VOLUME SET vol_qtree_path=\"$qtree_path\" WHERE vol_vserver=\"$vserver\" AND vol_volume=\"$volume\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "QTREE-PATH : 3/3 : OK"
								

Ces trois commandes vont une nouvelle fois envoyer une commande "Netapp" sur trois serveurs : qtree show -fields qtree-path,security-style qui va nous permettre de récupérer le "qtree-path" (l'endroit où seront stockés tous les qtrees de chaque volume ) afin de mettre à jour la table MDB_VOLUME et de préciser ce qtree-path pour CHAQUE volume possédant au moins un qtree. Cela va nous permettre de localiser nos qtree, ce qui va nous aider dans de futures commandes :p

UPDATE MDB_VOLUME SET vol_qtree_path="/qtree/path/récupéré/sur_le/serveur" WHERE vol_vserver="srv_test" AND vol_volume="test";



#remplir la table RELATION VAULT à partir du cluster Netapp
#snapmirror show -destination-volume volume -fields source-volume

for i in `echo "SELECT vol_volume FROM MDB_VOLUME WHERE vol_volume like \"%snap%\" OR vol_volume like \"%vault%\";" | msql -uadmin -sSRV_MySQL Artemis`
  do
    sshpass -p P@ssw0rd ssh lecteur@clu_netapp_srv_snap.local "snapmirror show -destination-volume $i -fields source-volume" |
      tail -n +3 |
      grep -v "your query" |
      sed -r 's/^ *//;s/ {1,}/\t/g' |
      sed 's/:/\t/g' |
      cut -f 3,5 |
      while read source destination ;
        do echo "INSERT INTO MDB_RELATION_VAULT (rel_source,rel_destination) VALUES (\"$source\",\"$destination\");" ;
      done |
      grep -v \"\"
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "RELATION VAULT : OK"
								

La commande ci-dessus va chercher ce que l'on appelle le volume primaire et le volume secondaire : Le volume secondaire est une "copie/sauvegarde" du volume primaire (là où les utilisateurs travaillent) située à un autre endroit dans un autre volume (dans le volume secondaire, donc.) La commande va permettre de faire le lien entre chaque volume secondaire et le volume primaire qui lui correspond ! Et de tout mettre dans une des tables de ma base de données : MDB_RELATION_VAULT

INSERT INTO MDB_RELATION_VAULT (rel_source,rel_destination) VALUES ("volume_34", "volume_34_secondaire");



# Faire le RAPPORT
# Mise en forme d'un rapport avec toutes les infos des autres tables de la base

echo "Création du rapport..."

echo "INSERT INTO MDB_RAPPORT (rap_v_server, rap_volume, rap_style, rap_vol_junction_path) SELECT vol_vserver, vol_volume, vol_style, vol_junction_path FROM MDB_VOLUME;" | msql -uadmin -sSRV_MySQL Artemis

echo "SELECT nbu_policy_name,fstab_volume,fstab_path,nbu_jpath,vol_volume,vol_vserver,vol_junction_path FROM MDB_VOLUME,MDB_FSTAB,MDB_NBU WHERE (fstab_volume=left(vol_junction_path,length(fstab_volume)) AND nbu_jpath=concat(fstab_path,'/',vol_volume)) OR (fstab_volume=vol_junction_path AND nbu_jpath=fstab_path);" | 
  msql -uadmin -sSRV_MySQL Artemis | 
  while read nbu_policy fstab_volume fstab_path nbu_jpath vol_volume vserver vol_junction_path ;
    do echo "UPDATE MDB_RAPPORT SET rap_nbu_policy_name=\"$nbu_policy\", rap_fstab_volume=\"$fstab_volume\", rap_fstab_path=\"$fstab_path\", rap_nbu_jpath=\"$nbu_jpath\" WHERE rap_vol_junction_path=\"$vol_junction_path\" AND rap_volume=\"$vol_volume\" AND rap_v_server=\"$vserver\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "SELECT vol_vserver, vol_volume, CONCAT(\"\\\\\\\\\\\\\\\\production-srv.genoscope.com\",'\\\\\\\\',vol_volume) AS CONCAT, nbu_policy_name FROM MDB_VOLUME, MDB_NBU WHERE nbu_policy_name=\"POLITIQUE_WINDOWS\" AND CONCAT(\"\\\\\\\\production-srv.genoscope.com\\\\\",vol_volume)=nbu_jpath;" | 
  msql -uadmin -sSRV_MySQL Artemis |
  while read vserver volume path policy ;
    do echo "UPDATE MDB_RAPPORT SET rap_nbu_policy_name=\"$policy\", rap_nbu_jpath=\"$path\" WHERE rap_volume=\"$volume\" AND rap_v_server=\"$vserver\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "CREATE TEMPORARY TABLE TEMP_NBU ( SELECT nbu_policy_name, vol_volume, vol_vserver, nbu_jpath, vol_junction_path FROM MDB_VOLUME, MDB_NBU, MDB_FSTAB WHERE vol_volume=RIGHT(nbu_jpath,LENGTH(vol_volume)) AND vol_volume=RIGHT(vol_junction_path,LENGTH(vol_volume)) AND fstab_volume=vol_junction_path AND fstab_path=nbu_jpath ); SELECT * FROM TEMP_NBU; SELECT nbu_policy_name, vol_volume, vol_vserver, nbu_jpath, vol_junction_path FROM MDB_VOLUME, MDB_NBU WHERE vol_volume=RIGHT(nbu_jpath,LENGTH(vol_volume)) AND vol_volume=RIGHT(vol_junction_path,LENGTH(vol_volume)) AND vol_junction_path  LIKE '%Vault%' AND vol_volume NOT IN (SELECT vol_volume FROM TEMP_NBU);SELECT nbu_policy_name, vol_volume, vol_vserver, nbu_jpath, vol_junction_path FROM MDB_VOLUME, MDB_NBU WHERE vol_volume=RIGHT(nbu_jpath,LENGTH(vol_volume)) AND vol_volume=RIGHT(vol_junction_path,LENGTH(vol_volume))  AND nbu_jpath NOT  LIKE '%Vault%' AND vol_volume NOT IN (SELECT vol_volume FROM TEMP_NBU);" | 
  msql -u admin -s SRV_MySQL Artemis |
  while read policy volume vserver nbu_jpath vol_junction_path ;
    do echo "UPDATE MDB_RAPPORT SET rap_nbu_policy_name=\"$policy\", rap_nbu_jpath=\"$nbu_jpath\", rap_vol_junction_path=\"$vol_junction_path\" WHERE rap_volume=\"$volume\" AND rap_v_server=\"$vserver\";" ;
  done | sed 's/\\/\\\\/g' |
msql -uadmin -sSRV_MySQL Artemis

echo "SELECT vol_vserver, vol_volume, vol_junction_path, nbu_jpath, nbu_policy_name FROM MDB_VOLUME, MDB_NBU WHERE CONCAT(vol_junction_path,'/')=RIGHT(nbu_jpath,LENGTH(concat(vol_junction_path,'/')));" |
  msql -uadmin -sSRV_MySQL Artemis |
  while read vol_vserver vol_volume vol_junction_path nbu_jpath nbu_policy_name ; 
    do echo "UPDATE MDB_RAPPORT SET rap_nbu_jpath=\"$nbu_jpath\", rap_nbu_policy_name=\"$nbu_policy_name\" WHERE rap_v_server=\"$vol_vserver\" AND rap_volume=\"$vol_volume\" AND rap_vol_junction_path=\"$vol_junction_path\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "INSERT INTO MDB_RAPPORT (rap_v_server, rap_v_qtree, rap_style, rap_volume, rap_vol_junction_path) SELECT qtree_vserver, qtree_qtree, qtree_style, qtree_volume, qtree_path FROM MDB_QTREE;" | msql -uadmin -sSRV_MySQL Artemis

echo "SELECT nbu_policy_name , nbu_jpath , qtree_path  , qtree_vserver , qtree_volume , qtree_qtree FROM MDB_NBU , MDB_QTREE WHERE CONCAT(qtree_volume,'/',qtree_qtree)=RIGHT(nbu_jpath,LENGTH(CONCAT(qtree_volume,'/',qtree_qtree)));" | 
  msql -uadmin -sSRV_MySQL Artemis |
  while read nbu_policy_name nbu_jpath qtree_path qtree_vserver qtree_volume qtree_qtree ; 
    do echo "UPDATE MDB_RAPPORT SET rap_nbu_policy_name=\"$nbu_policy_name\", rap_nbu_jpath=\"$nbu_jpath\", rap_vol_junction_path=\"$qtree_path\" WHERE rap_volume=\"$qtree_volume\" AND rap_v_qtree=\"$qtree_qtree\" AND rap_v_server=\"$qtree_vserver\";" ;
  done |
msql -uadmin -sSRV_MySQL Artemis

echo "UPDATE MDB_RAPPORT SET rap_volume_destination = (SELECT rel_destination FROM MDB_RELATION_VAULT WHERE rel_source=rap_volume LIMIT 1);" | msql -uadmin -sSRV_MySQL Artemis

echo "Rapport généré opti oignons :"
echo "SELECT rap_id,rap_nbu_policy_name,rap_volume,rap_style,rap_vol_junction_path,rap_volume_destination FROM MDB_RAPPORT;"
echo "SELECT rap_id,rap_nbu_policy_name,rap_volume,rap_style,rap_vol_junction_path,rap_volume_destination FROM MDB_RAPPORT;" | msql -uadmin -sSRV_MySQL Artemis
echo "Fin du script"