Discussion :

[supcomingenieur]

Bonsoir tus le monde,

ce que je veux faire est assez simple sauf que que j'arrive pas a trouver la bonne combinaison de commandes shell pour le faire. Au fait j'ai un fichiers enorme et je voudrai supprimer les 1000 premières et les renvoyer dans un autre fichier.
j'ai essayé avec sed '1,1000' fichier.txt >out.txt mais je remarque que "fichier" a toujours les lignes effacées et que "out" ne contient pas les lignes effacées mais celles qui restent de "fichiers" après la suppresion .
comment faire??
merci

[Invité]

Comme ça?

Code :

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

1
2
3
head -1000 fichier.txt > out.txt
nb_ligne=$(wc -l fichier.txt | cut -d" " -f1)
tail -$(($nb_ligne-1000)) fichier.txt > nouveau_fichier.txt

[disedorgue]

Bonjour,
En plus simple:

Code :

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

1
2
3
4
5
6
7
$ head -1000 fichier.txt > out.txt
$ head -n -1000 fichier.txt > nouveau_fichier.txt
$ wc -l fichier.txt nouveau_fichier.txt out.txt
   9405 fichier.txt
   8405 nouveau_fichier.txt
   1000 out.txt
  18810 total

Version sed:

Code :

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

1
2
3
4
5
6
7
8
$ wc -l fichier.txt
9405 fichier.txt
$ sed -n -e '1,1000p' fichier.txt >out.txt
$ sed -i -e '1,1000d' fichier.txt
$ wc -l fichier.txt out.txt
   8405 fichier.txt
   1000 out.txt
   9405 total

[supcomingenieur]

Merci pour toutes vos réponses je ne serai jamais arrivée à deviner ça toute seule. J'ai fait toutes fois quelques modifications sur la deuxième commande voici le script complet

head -10 fichier > out les 10 premières lignes sont renvoyée dans out
tail -n +11 fichier > intermediaire intermediaire contient les lignes de fichier sauf les 10 premières
rm fichier fichier est supprimé
mv intermediaire fichier intermediaire est renommé en fichier

j'ai cependant une autre question: comment je fait pour que "fichier" et "out" soient des variables de sorte que a chaque fois que j'exécute mon script je peux les changer en fonction de mes besoins????

merci

[ok.Idriss]

Ben tu remplaces les noms des fichiers concernés par des variables, j'ai du mal à voir ce qui te pose problème la dedans

[supcomingenieur]

Oui c'est vrai j'avais trouvé juste après avoir posté désolé c'était un peu bête merci beaucoup et bonne journée. Si quelqu'un pourrait marquer résolu ça sera gentil.

[ok.Idriss]

Pour mettre en résolu c'est le bouton en bas de page

[disedorgue]

Exact, je devais être fatigué quand j'ai répondu:

ceci est faux

Code :

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

head -n -1000 fichier.txt > nouveau_fichier.txt

mais je vois que tu as corrigé de toi-même

Code :

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

tail -n +11 fichier > intermediaire

Par contre, si c'est vraiment des très gros fichiers, je te conseille la version sed avec la variante suivante qui devrait être plus rapide que tail:

Code :

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

1
2
$ sed -n -e '1,1000p;1001q' fichier.txt >out.txt
$ sed -i -e '1,1000d;1001q' fichier.txt

Ici, on ne traite que les 1000 premières lignes du fichier pour chaque commande et on sort à la 1001 ème ligne.
Tandis que pour la version tail, on traverse tout le fichier.

Sinon, quand tu passes des arguments à un script shell, comme par exemple:

Code :

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

script.sh toto tata

dans le script lui-même, la valeur toto se trouve dans $1 et la valeur tata se trouve dans $2.
exemple:

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
$ cat script.sh
#!/bin/sh
 
if [ "$#" -ne "2" ]
then
        echo "USAGE:$0 prend 2 paramêtres"
        exit 1
fi
echo "la valeur de \$1 est: $1"
echo "la valeur de \$2 est: $2"
 
$ ./script.sh
USAGE:./script.sh prend 2 paramêtres
$ ./script.sh toto tata
la valeur de $1 est: toto
la valeur de $2 est: tata
$ ./script.sh toto tata titi
USAGE:./script.sh prend 2 paramêtres

[Invité]

J'oublie toujours le "tail -n" quand j'en aurais besoin...
En tout cas c'est vrai que la méthode avec sed est préférable. Plis rapide et en plus tu ne passes pas par un fichier temporaire.

[supcomingenieur]

merci pour vos réponses
Au fait la première commande avec sed fonctionne et le fichier out contient en effet les 1000 premières lignes de "fichier" mais la deuxième commande ne fonctionne pas je ne sais pourquoi mais le resultat est erroné normalement je dois avoir le fichier "fichier" SANS les 1000 premières lignes qui on été transféré vers out

[disedorgue]

Ok, j'ai compris, la première version de sed fonctionne bien mais la version optimisé ne fonctionne pas car comme je le force à sortir à la 1001 ligne, il ne reste que celle-ci en fait.
Ce qui veut dire que sed aussi doit traverser tout le fichier
Donc le head et le tail sont suffisant.

[supcomingenieur]

non pas du tout ce n'est pas ce que je voulais dire
j'ai un petit peu modifié ta dernière suggestion voila le script que ça donne

Code :

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

1
2
sed -n -e '1,1000p;1001q' $1 >$2
sed '-1,1000d' $1 -i

ça fonctionne parfaitement si $1test et $2 =test_final
test_final contiendra les 1000 première ligne de test et test sera mis a jour et les 1000 premières lignes seront effacées

voila merci beaucoup

[jack-ft]

Bon, c'est pas pour chipoter (ce n'est pas mon genre!), mais si c'est, par exemple, un fichier de log en cours de construction par un autre process et qu'il n'a pas encore atteint 1000 lignes, le premier sed va copier le total du contenu courant dans $2 (par exemple 300 lignes).
Pendant ce temps, l'autre process génère 3 ou 4 lignes.
Puis le 2ème sed va vider complètement $1 en supprimant les 304 premières lignes.
Et hop! on a perdu les lignes 301 à 304...

[supcomingenieur]

justement!!! c'est le problème que je rencontre actuellement dans mon code java car la classe responsable de créer mon fichier "fichier" peut prendre du retard ce qui fait que celle responsable d'exécuter le script (que j'ai réalisé plus haut) peut accéder au fichier trop tôt !

Ma question est donc la suivante: y a-t-il un moyen pour mettre en pause un script shell qui prend du temps à s'exécuter. J'ai pensé que le script qui me génère le fichier "fichier" pourrait être mis en pause lorsque le script rassemble déja 1000 lignes. De cette manière je pourrais faire appel au script de lecture (défini plus haut)

est ce que c'est faisable ?

[Flodelarab]

Comme personne n'a encore ramener sa fraise avec sa solution awk, je m'y colle:

Code :

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

awk '(NR<1001){print >debut.txt} (NR>1000){print >fin.txt}' initial.txt

Et comme awk n'est pas choupinou, il ne fait pas de remplacement à la volée. Il faut donc faire un truc du genre:

Code :

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

1
2
3
exec 3<initial.txt
rm -f initial.txt 
awk '(NR<1001){print >"debut.txt"} (NR>1000)' 0<&3 >initial.txt

[disedorgue]

Je pense (oui, ça m'arrive ) que la solution awk avec le rm n'est pas recommandable dans ce cas, car à priori, c'est sur un fichier log d'un processus java en cours.
Or, la remise à zéro d'un fichier ne change pas son inode et est donc toujours exploitable par le processus en cours, mais un effacement du fichier pour ensuite le recréer ne garanti pas l'utilisation du même inode et donc le processus en cours continuera d'écrire sur le disque pour un fichier n'ayant plus de référence.

Concernant la mise en pause du script, c'est possible en envoyant un signal STOP au processus et ensuite, il suffirait de renvoyer un signal CONT mais ceci n'est pas du tout propre surtout quand on a la possibilité de mettre des contraintes dans le script.
Par exemple, il suffit de n'executer les commandes de récupération des 1000 lignes et de suppression de celle-ci que quand on a atteint les dit 1000 lignes:

Code :

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

1
2
3
4
5
6
while [ "$(sed -n -e '$=' fichier.txt)" -lt "1000" ]
do
   echo "on attend 10 secondes"
   sleep 10
done
# ici on fait les actions prévues

[supcomingenieur]

Ma méthode avec le while me convient très bien. Je l'ai testée avec quelques modifs près et ça a fonctionné parfaitement au début. Mais après ça a commencé a me retourner l'erreur suivante :

line 1: [: : integer expression expected

voici mon Script "tester":

Code :

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

1
2
3
4
5
6
7
while [ "$(sed -n -e '$=' $1)" -lt "1000" ]
do
  echo "on attend 10 secondes"
  sleep 10
done
sed -n -e '1,1000p;1001q' $1 > $2
sed '1,1000d' $1 -i

l'exécution est la suivante:

Code :

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

bash tester test1 test2

merci

[jack-ft]

Code :

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

1
2
3
4
5
6
while [ "$(sed -n -e '$=' fichier.txt)" -lt "1000" ]
do
   echo "on attend 10 secondes"
   sleep 10
done
# ici on fait les actions prévues

J'avoue que pour compter le nombre de lignes d'un fichier, j'aurais plus facilement tendance à utilise wc:

Code :

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

1
2
3
4
5
6
while [ $(wc -l fichier.txt) -lt 1000 ]
do
   echo "on attend 10 secondes"
   sleep 10
done
# ici on fait les actions prévues

@disdorgue: est-ce moins efficace?

[HS]
J'utilise 'wc' de préférence sans les guillemets et avec 'eq', pour assurer la portabilité sous AIX qui a tendance à utiliser un formatage différent de linux et qui peut générer des résultats a priori surprenants lors de la comparaison de nombres comme des chaines:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
$ uname -a
AIX zorglub 1 6 000XXXXXX00
$ [ $(echo coucou | wc -l) -eq 1 ]; echo $?
0
$ [ $(echo coucou | wc -l) = 1 ]; echo $?  
0
$ [ "$(echo coucou | wc -l)" -eq 1 ]; echo $?
0
$ [ "$(echo coucou | wc -l)" = 1 ]; echo $?  
1
$ echo coucou | wc -l
       1

[/HS]

[jack-ft]

Merci d'utiliser la balise CODE (le # dans la barre d'outils)!

justement!!! c'est le problème que je rencontre actuellement dans mon code java car la classe responsable de créer mon fichier "fichier" peut prendre du retard ce qui fait que celle responsable d'exécuter le script (que j'ai réalisé plus haut) peut accéder au fichier trop tôt !

Ma question est donc la suivante: y a-t-il un moyen pour mettre en pause un script shell qui prend du temps à s'exécuter. J'ai pensé que le script qui me génère le fichier "fichier" pourrait être mis en pause lorsque le script rassemble déja 1000 lignes. De cette manière je pourrais faire appel au script de lecture (défini plus haut)

est ce que c'est faisable ?

Du coup, ça ressemble fichtrement à un problème (au demeurant assez classique) de producteur/consommateur pour lequel existe une littérature passablement abondante...

Le producteur est-il log4j?

Si le producteur ouvre un seul file descriptor sur le fichier pour toute la session, alors il faut prendre certaines précautions (comme indiqué par disedorgue).
Si le producteur réouvre un nouveau file descriptor (en mode append) sur le fichier (d'après son nom) à chaque écriture d'une ligne, on a plus de souplesse.

La solution classique producteur/consommateur sur une ressource limitée (comme un buffer) est en général la suivante:

Code pseudo :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Producteur:
Tant qu il reste des choses à faire
  Faire ce qu il y a à faire
  Pour l écriture dans le buffer:
    Tant que le buffer est plein, attendre.
    écrire dans le buffer
 
Consommateur:
Tant qu il reste des choses à faire
  Faire ce qu il y a à faire
  Pour la lecture du buffer:
    Tant que le buffer est vide, attendre
    lire dans le buffer

En principe, il faut que le test sur le buffer et sa manipulation (verrouillage) soient faits dans un mutex (en exclusion mutuelle), par exemple, avec un sémaphore.

Dans ton cas précis, le test "le buffer est vide" correspond clairement à "le fichier contient moins de 1000 lignes".
Le test "le buffer est plein" correspond soit à "le fichier contient 1000 lignes" soit à "le fichier contient 100000 lignes" si tu as suffisamment de place disque et si tu gères proprement la pseudo-simultanéité entre lecture et écriture (voir problèmes de inodes/file descriptors)

[disedorgue]

J'avoue que pour compter le nombre de lignes d'un fichier, j'aurais plus facilement tendance à utilise wc:

Code :

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

1
2
3
4
5
6
while [ $(wc -l fichier.txt) -lt 1000 ]
do
   echo "on attend 10 secondes"
   sleep 10
done
# ici on fait les actions prévues

@disdorgue: est-ce moins efficace?

C'est surtout que wc -l affiche aussi le nom de fichier et donc pour comparer avec un nombre...:

Code :

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

1
2
$ wc -l fich1.xml
6 fich1.xml