Discussion :

[disedorgue]

Un peu compliqué, une légère modification du précédent suffit:
Comme par exemple ci-sessous (pas testé):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
indexline=1000
indexprev=1
while [ ICI TEST FIN PROCESS ]
        while [ "$(wc -l <$1)" -lt "${indexline}" ]
        do
                echo "on attend 10 secondes pour le fichier $1"
                sleep 10
        done
        echo "fichier $1 prêt, MAJ de $2"
        >$2
        sed -n -e "${indexprev},${indexline}p" $1 >> $2
        indexprev=$(expr ${indexprv} + 1000)
        indexline=$(expr ${indexline} + 1000)
done

Reste 2 souci à résoudre:
1 - Avoir un nommage dynamique du fichier de sortie car ici on écrit toujours dans le fichier $2
2 - Comment savoir que le processus est terminé (celui qui écrit dans $1) ?

Pour le 1, il suffirait par exemple de remplacer dans le script $2 par $2.${indexline}

[jack-ft]

au fait le fichier est remplie par une requête shell SNMP WALK.
lorsque la requête stocke 1000 lignes dans le fichier, des dernière sont transférées vers un autre fichiers. et ainsi de suite jusqu'a ce que la requête soit terminée. donc normalement lorsque SNMP walk s'arrête le fichier se retrouve vidé.

Comme le dit disedorgue, il y a un problème d'algorithme!

J'ai l'impression qu'il serait fort utile de clarifier le besoin!

J'avais cru comprendre que le producteur et le consommateur des lignes étaient décorrélés, et qu'il pouvait arriver que le producteur produise moins vite ou, au contraire, plus vite que le consommateur.

Le consommateur pouvant être en attente du producteur, s'il voit un nombre de lignes inférieur à 1000, il est face à un dilemme:

• soit le producteur est en retard, et le consommateur doit patienter pour que le producteur remplisse les 1000 lignes
• soit le producteur a complètement terminé de produire, et le consommateur doit générer un dernier bloc avec le paquet de lignes restant, puis terminer

Quelle est la communication ou le critère qui permet au consommateur de lever l'ambiguïté, c'est-à-dire de savoir si le producteur a terminé sa production (voir la partie rouge de ta citation) ou s'il est en retard?

Si le consommateur ne sait pas quand le producteur a terminé, comment peux-tu espérer que le consommateur termine (pour produire ce dernier bloc avec un nombre de lignes différent de 1000)?

Soit il faut que tu mettes en place une solution à base de RPC, corba ou autre communication inter-process pour que le producteur indique qu'il a terminé,
soit, plus basiquement, tu peux ajouter dans le code du producteur quelque chose comme: "touch finished" (exécuté lorsqu'il a terminé de produire) et, dans le code du consommateur un test sur l'existence du fichier "finished" qui servira à terminer avec un dernier bloc de moins de 1000 lignes.

[ORTHOGRAPHE] PS: Au fait, en français "normal", les expressions "au fait" et "en fait" n'ont pas le même sens. En fait, il me semble que tu as un peu tendance à les confondre... [/ORTHOGRAPHE]

[supcomingenieur]

disedorgue,
ton script fonctionne bien mais le problème est que le fichier $1 est rempli à une vitesse supérieure à celle avec laquelle il va être lu, ce qui fait que je rate toujours des parties du fichier.

par exemple rien qu'au lancement de ton script et de ma requête simultanément, $1 débute avec une taille égale à 3000 lignes ce qui fait que ça fausse tout.
bien sur je ne pourrais pas agir sur la vitesse d'exécution de la requête. mais je peux par contre faire en sorte que la lecture soit indépendante de l’écriture (donc peu importe à quelle taille est arrivée $1 on va toujours le lire par bloc de 1000 lignes)

voici le script que j'ai fait
mais je rencontre des problèmes syntaxique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
ancienne_taille=0
max_index=1
max_index=1000
 
 
while [ condition d'arrêt de la requête ]
do
  sed -n '$=' $1 > size
  while read line
  do
    nouvelle_taille=$line
  done < size
  rm size
 
  while [ "$(expr $nouvelle_taille - $ancienne_taille) -lt "1000" ]
  do 
    echo "attendre que 1000 nouvelles lignes soient rajoutées dans $1"
    sleep 10
    sed -n '$=' $1 > size
    while read line
    do
      nouvelle_taille=$line
    done < size
    rm size
    echo "nouvelle taille $nouvelle_taille"
  done
 
echo "1000 nouvelles lignes viennent sont rajoutées"
sed -n -e "$last_index,"$max_index"p" $1 > $2
 
ancienne_taille=$nouvelle_taille
last_index=$(expr $last_index + 1000)
max_index=$(expr $max_index + 1000)
 
done

[disedorgue]

Le script ne perd pas de morceau, il le fait par étape de 1000 ligne, quelque soit la taille au départ du fichier.
Si tu veux t'en convaincre, il suffit de retirer la ligne 11 ( >$2 ) qui remet le fichier de sortie à zéro avant d'insérer les 1000 lignes suivantes.

Il manque toujours la condition qui permet de savoir si le processus qui ecrit dans $1 est fini.

[supcomingenieur]

tout a l'heure tu m'a suggéré une idée très interessente c'est de creer un nouveau fichier $2 a chaque fois que milles nouvelles lignes sont ajoutée. je trouve que ça me conviendra mieux car le code java qui va exploiter $2 peut être très en retart et donc je voudrai garder la trace de $2. (je précise que le code que tu m'a fourni sera exécuté 7 fois en parallèles )
comment je pourrais faire cette création de fichiers dont le nom seraient des indexes 1,2,3 ect..
merci

[disedorgue]

En rajoutant (en rouge) les index au nom du fichier de sortie:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
indexfile=1
indexline=1000
indexprev=1
while [ ICI TEST FIN PROCESS ]
        while [ "$(wc -l <$1)" -lt "${indexline}" ]
        do
                echo "on attend 10 secondes pour le fichier $1"
                sleep 10
        done
        echo "fichier $1 prêt, MAJ de $2"
        >$2.${indexfile}
        sed -n -e "${indexprev},${indexline}p" $1 >> $2.${indexfile}
        indexprev=$(expr ${indexprv} + 1000)
        indexline=$(expr ${indexline} + 1000)
        indexfile=$(expr ${indexfile} + 1)
done

[supcomingenieur]

bonjour, merci beaucoup pour l'aide sur le script.
j'en ai crée un autre avec des conditions multiples dans la boucle while, les conditions sont reliées par un AND logique. cependant je remarque que on sort de la boucle alors que les conditions ne sont pas toutes remplies.

voila le scripts

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
while [[ "$(wc -l <$3/prefix)" -lt "$2" && "$(wc -l <$3/maskLength)" -lt "$2" ]]
do
      echo "on attend 10 secondes pour le fichier prefix et maskLength"
      sleep 10
done
echo "fichiers prêts, MAJ de fichiers auxiliaires"
sed -n -e "$1,"$2"p" $3/prefix > $4/prefix
sed -n -e "$1,"$2"p" $3/maskLength > $4/maskLength
paste -d ':' "$4/prefix" "$4/maskLength" > $5
cp $4/prefix /var/lib/mysql/OrangeTunisie

je remarque que le fichier maskLength est crée dans le repertoire $4 mais il est vide.
comment régler ce probleme??

[disedorgue]

Je ne relève pas d'erreur particulière qui pourrait expliquer le souci que tu rencontres à part éventuellement la syntaxe des commande sed:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sed -n -e "$1,"$2"p" $3/prefix > $4/prefix
sed -n -e "$1,"$2"p" $3/maskLength > $4/maskLength

que j'aurai écris plutot comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sed -n -e "$1,$2p" $3/prefix > $4/prefix
sed -n -e "$1,$2p" $3/maskLength > $4/maskLength

Mais je ne pense pas que cela soit le problème. Pour moi, le problème est ailleurs dans ton script.

PS: Je trouve qu'il y a encore pas de souci pour une discussion Résolue

[supcomingenieur]

je suis désolée que cette discussion ait pris cette tournure. mais la programmation c'est vraiment pas facile. Merci pour ton aide en tout cas.
Voila ou j'en suis maintenant. Mon script me permet de suivre l'évolution de mes requêtes extérieure qui, elles écrivent dans d'autres fichiers (qu'on appelerai fichiers X). a chaque fois que ces fichiers atteignent 1000 lignes, ces dernières sont transférées dans d'autres fichiers (qu'on appelera fichiers Y) pour êtres chargées dans des tables SQL.
j'ai modifiée le script de façon à ce que les fichiers de catégorie X ne renvoient leurs 1000 nouvelles lignes dans les fichiers Y que si la dernière version des fichiers Y soit déja chargée dans la base SQL (à fin de ne perdre aucun morceau des fichiers X).
je rencontre à ce niveau deux problèmes:
le premier est que parfois le scripts se plante et ne veux plus recharger les fichiers Y je ne comprend pas pourquoi d'ailleurs.
le deuxième est qu'il faut que je reboucle avec une clause while sur mon scripts pour qu'il s'exécute tant les les requêtes qui remplissent X ne soient pas terminée. mais je ne trouve pas la condition d'arrêt de mon while.

une autre question. est ce que c'est possible d'inrtégrer une instruction JAVA dans un script shell(si ceci est possible c'est très facile de trouver la condition d'arrêt puisqu'il suffit que les fichiers X soit fermés).

je m'excuse pour la longueur du message, j'espère avoir été claire et encore merci pour ton aide.

[disedorgue]

Pas de souci, je pensais juste que tu pouvais rouvrir la discussion au lieu de la laisser résolue, pour que plus de personnes la suivent.
Pour ta première question, je manque d'éléments pour te dire pourquoi cela bloque de temps à autre. Dans le bout de script que tu as donné, on voit qu'il y a 5 paramètres, mais on ne connait pas leur valeurs quand tu fais tes tests et on ne sait pas à quoi tu les utilises dans le reste du script...
Concernant tes 2 dernières questions, on a quelque moyen de savoir si un fichier est utilisé et aussi de savoir si un programme est fini.
Est-ce que le programme qui remplie les fichiers X se termine et se trouve sur la même machine, car si c'est le cas, on peut le surveiller pour déterminer quand les fichiers ne sont plus utilisés ?

[supcomingenieur]

Bonjour,
Oui, en effet. le programme qui remplie les fichiers X est un script shell qui contient la ligne suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

snmpwalk -Ovq -v2c -c INTERNET@orange 10.53.3.150  oid

c'est une commande snmp qui interroge la table de routage "INTERNET" se trouvant sur le routeur à l'addresse 10.53.3.150. En fait j'ai lance cette commande 7 fois de manières indépendante (chacune pour récupérer un type de données bien déterminées). j'aimerai savoir comment détecter la fin de la commande car le fichier résultant va être utilisé par un programme java.

concernant le script, je vais te le mettre en nommant les paramètres pour que ca soit claire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
while [[ "$(wc -l <$3/prefix)" -lt "$2"  ||  "$(wc -l <$3/maskLength)" -lt "$2" ]];
do
echo "on attend 10 secondes pour le fichier prefix et maskLength"
sleep 10
done
echo "fichiers prêts, MAJ de fichiers auxiliaires"
sed -n -e "$1,"$2"p" $3/prefix > $4/prefix
sed -n -e "$1,"$2"p" $3/maskLength > $4/maskLength
paste -d ':' "$4/prefix" "$4/maskLength" > $5
paste -d ':' "$4/prefix" "$4/maskLength" > /var/lib/mysql/OrangeTunisie/prefix

$1= 1 (sera incrémentée de 1000 lignes)
$2=1000 (sera incrémenté de 1000 lignes)
$3= nom d'un repertoire
$4nom d'un autre répértoire
$5=nom d'un fichier cible, ce fichier est une concaténation des fichier "prefix" et "mask"
il est utilisé pour être chargé dans une table SQL.
J'ai une question: la première ligne du script est ce qu'elle est équivalente à "tant que les fichiers ne contiennent pas 1000 lignes" ou "tant que les fichiers n'ont pas de 1000 NOUVELLES lignes"?

merci

[disedorgue]

Pour savoir si un script est fini, le plus est que cela soit lui-même qui le dit en posant un fichier temporaire au démarrage de celui-ci et en le supprimant à la fin. Comme ça, les autres script n'ont qu'à détécter la présence du fichier et d'agir en conséquence.

Concernant l'autre point, la boucle dit explicitement:
tant que (("$(wc -l <$3/prefix)" inférieur à $2) ou ("$(wc -l <$3/maskLength)" inférieur à $2))
Ce qui veut dire que quand tu es dans cette boucle, il faut obligatoirement que le programme qui remplie les fichiers, le fasse au delà de la valeur de $2.

[supcomingenieur]

merci beaucoup pour la réponse.
j'ai mis le script dans une boucle extérieur (avec une condition d'arrêt simple) et j'ai testé avec des fichier de petite taille et j'ai remarqué que finalement mon algorithme fonctionne très bien. le seul ennui est que mon fichier de départ peut avoir un nombre de lignes qui n'est pas multiples de 1000. Donc pour les lignes restantes (disons 300lignes) il attendra indéfiniment que la taille passe à milles (ce qui est indiqué dans la condition bien sur).
Une idée pour corriger ce petit détail?

[disedorgue]

Rajouter la fameuse condition d'arret du script qui remplie les fichiers X.

[supcomingenieur]

le fait d'ajouter la condition d'arrêt ne résout pas le problème des lignes restantes. Pour ce faire j'ai du déterminé le nombre de lignes restantes ($1= taille fichier-taille table SQL)
et j'ajoute ce script:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sed -n '$1,$p' $2/prefix.txt > $3/prefix.txt
sed -n '$1,$p' $2/maskLength.txt > $3/maskLength.txt
paste -d ':' "$3/prefix.txt" "$3/maskLength.txt" > "$4"

ce code permet de copier les $1 dernières lignes des deux fichiers prefix et maskLength
mais j'ai une erreur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sed: -e expression #1, char 2: unknown command: `1'

apparament, le paramètre $1 n'est pas lu. Comment faire??
merci

[disedorgue]

remplace les simple quote " ' " par des double quotes " " " dans tes appels sed afin que tes variables soient interprétées.

[supcomingenieur]

Merci beaucoup.

[supcomingenieur]

Bonjour,
Toujours avec le même script je voudrai modifier la condition du while de cette manière:
au lieu de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while [ "$(wc -l <path.txt)" -lt "1000" ]

je voudrais appliquer une fonction sur le fichier path.txt, et si le nombre de lignes retourné est 1000 --> entrer dans la boucle.

voila ce que je veux faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while [  sed '/[0-9A-F] $/{N;s/\n//};s/\"//g;s/.. .. //' path.txt | "$(wc -l)" -tl "1000" ]

mais la syntaxe est fausse, comment la corriger??
merci

[ok.Idriss]

Bonjour.

Normalement, les messages d'erreurs devraient t'aiguiller un peu

-tl je ne connais pas cet opérateur
-lt signifie "inférieur stricte" ce qui ne correspond pas à la spécification :

je voudrais appliquer une fonction sur le fichier path.txt, et si le nombre de lignes retourné est 1000 --> entrer dans la boucle.

Dans ce cas -eq si c'est exactement 1000 ou -ge "supérieur ou égal".

Ensuite la sous-exécution doit concerner l'ensemble de la commande sed ...|wc et non uniquement wc.

En bash (à tester car je n'ai pas vérifié la regexp entre autres) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[[  $(sed '/[0-9A-F] $/{N;s/\n//};s/\"//g;s/.. .. //' path.txt | wc -l) -ge 1000 ]]

Cordialement,
Idriss

[disedorgue]

On va dire que la regex est fonctionnel et doit faire se que l'on veut tant que la ligne "complete" ne se retrouve pas sur plus de 2 lignes dans le fichier...