guppy a écrit 345 commentaires

Là, tu écris. Sur du RAID 1, quand tu écris, tu dois écrire simultanément (ou presque) sur les deux disques. C’est donc normal que l’écriture RAID soit 2× plus lente.

En lecture (tu n’as pas fait le test) tu peux espérer au moins la même vitesse. Tu peux gagner si tes deux disques ne sont pas sur la même nappe et donc peuvent faire des lectures parallèles (la moitié des données sur chaque disque).

On peut supposer que les 2 écritures seront parallélisées et donc que la vitesse sera identique. Ce que dit wikipedia est intéressant :

Any read request can be serviced and handled by any drive in the array; thus, depending on the nature of I/O load, random read performance of a RAID 1 array may equal up to the sum of each member's performance,[a] while the write performance remains at the level of a single disk. However, if disks with different speeds are used in a RAID 1 array, overall write performance is equal to the speed of the slowest disk.[14][15]

Synthetic benchmarks show varying levels of performance improvements when multiple HDDs or SSDs are used in a RAID 1 setup, compared with single-drive performance. However, some synthetic benchmarks also show a drop in performance for the same comparison.

En résumé, lecture : somme des vitesses des disques, écriture : vitesse du disque le plus lent.

En fait, SATA utilise un encodage 8b/10b (pour faire simple, pour récupérer 8 bits il en transmet 10) :

https://en.wikipedia.org/wiki/Serial_ATA#Physical_layer
https://en.wikipedia.org/wiki/8b/10b_encoding

Donc du SATA à 6 Gb/s transmets à 6 / 10 = 0,6 Go/s maximum.

Je postule aussi, je suis curieux.

Les premiers logiciels libres (au sens réellement placés sous des licences libres, et pas juste un informel "faites ce que vous voulez avec mon code") ont été écrits sur des systèmes propriétaires avec des compilateurs propriétaires grâce à des éditeurs propriétaires. Ce qui a permis d'avoir un éditeur libre, puis un compilateur libre, puis un système d'exploitation libre. Bref d'initialiser ( bootstrap).

En installant ce logiciel libre dans un environnement complètement non libre personne ne parlait d'os libre ou d'un truc du genre. Là c'est vrai que quand on parle de serveur open hardware on s'attend de prime abord à ce qu'il y ai plus que juste le chassis…

Néanmoins on est d'accord il faut bien commencer par quelque part et je félicite l'initiative.

Avoir en quoi ? Je le répète, j'en ai que foutre de ce monsieur.

Détends-toi quand même. Moi aussi cette histoire m'intéresse peu, je ne le connais pas non plus, mais il y a quand même un minimum de respect à avoir pour les autres. Peut-être qu'il te lit. Qu'il soit victime d'une situation de merde est possible, lire tous tes 3 posts que t'en as rien foutre de lui (22 commentaires sur le journal, c'est pourquoi ? pour essayer de montrer que t'as raison ?), c'est gerbant.

Les ad-hominem ça va bien 5 minutes. Vous pourriez le remercier, c'est un peu grâce à lui si ça va être corrigé avant que ça soit compromis. Enfin ça c'est qu'il faut espérer, avec tous les bots qui se baladent, ça m'étonne un peu que ce soit encore sain.

J'ai fait le test, chrono en main, il m'a fallu 10 minutes à peine pour obtenir un shell sur votre serveur (que j'ai immédiatement fermé car mon but n'est pas d'aller plus loin).

Là tu vas trop loin, tu prends des risques inutiles.

Tout le monde a bien compris qu'ils ont merdé. D'ailleurs, qu'ils aient merdé n'est pas le pire, c'est surtout le manque d’honnêteté intellectuelle qui va leur faire du tort à mon avis.

Pour être plus précis, elle a toujours été définie par l'implémentation. Mais la norme indique un nombre minimums de caractères à supporter :

The implementation shall be able to translate and execute at least one program that contains at least one instance of every one of the following limits:
…
* 63 significant initial characters in an internal identifier or a macro name (each universal character name or extended source character is considered a single character)
…

(extrait de C99)

Ce qui veut dire qu'un compilo peut parfaitement respecter cette norme en ne considérant que les 63 premiers caractères des identifiants internes. Un identifiant d'une taille supérieure, même si il fonctionnerait sur votre implémentation, serait donc potentiellement non portable. Donc il y a un bien une limite pratique de 63 caractères pour les identifiants internes, 31 pour les externes. C11 ne change pas ce point, mais C89 avait bien une limite à 6 caractères (en pratique toujours, mais rien n'interdisait aux compilos de la repousser à ma connaissance).

Le premier janvier par exemple on dirait que la température du disque dur était inférieure à 10°C, soit très proche de la limite basse (5° C la plupart du temps, exemple au hasard : http://www.seagate.com/staticfiles/maxtor/en_us/documentation/data_sheets/diamondmax_16_data_sheet.pdf). Il semblerait d'ailleurs que la température optimale de fonctionnement soit aux alentours de 40° (vieux mais ça donne un ordre d'idée : http://www.tomshardware.fr/articles/Google-disque-dur,1-19761.html). On peut donc imaginer qu'à moins de 10°C on réduit fortement son espérance de vie.

J'imagine que vous ne pouvez pas y faire grand chose, mais vous y avez déjà réfléchi ?

Effectivement le plus gros problème c'est la non-homogénéité. Personnellement sur un projet que je ne débute pas je m'en fiche de la convention (je m'adapte facilement), mais je déteste quand chacun a fait sa petite sauce.

Et quand c'est moi qui débute un projet, camelCase. Je cherche la concision et je trouve que dans ce cas c'est le meilleur choix.

Il y a d'ailleurs un gros framework avec cette convention, c'est Qt. Et c'est un vrai bonheur.

Je crois que la traversée des NAT n'est pas le seul problème malheureusement.

Il y a quelques années j'avais bricolé un système à base de tunnel SSH pour des collègues qui faisaient du dépannage à distance (via UltraVNC). Ca fonctionnait, ma boite s'en est servi un temps, puis ils sont passés à TeamViewer. Raison : beaucoup plus fluide sur une connexion adsl. Je ne sais pas si c'est toujours le cas actuellement, mais j'imagine que oui ; vnc n'attire plus grand monde aujourd'hui d'après ce que je vois, tandis que teamviewer et compagnie sont beaucoup utilisés donc plein de licences => pognon => développement.

Pour l'exemple :

$ cat 2015.csv
c000,Z,bob,bob.z,000000
$ cat 2016.csv
c999,Z,bob,bob.z,(déjà attribué)
$ join -t',' <(tail -n +1 2016.csv | sort -k4,4 -t,) <(tail -n +1 2015.csv | sort -k4,4 -t,) -j 4 -o 1.1,1.2,1.3,1.4,2.5
c999,Z,bob,bob.z,000000

Le tail -n +2 fait disparaître la première ligne. Si l'entête est présente, il est nécessaire.

Petite correction par rapport à mon message précédent, j'ai compris que l'identifiant de la ligne est le champ 4 (bob.z). Dans mon précédent message j'avais supposé qu'il était composite (champs 2 à 4). Ça me paraissait pas clair, certainement parce qu'en SQL on a l'habitude de le faire figurer en premier.

Donc si on considère que tes 2 fichiers ont une entête d'une ligne et que l'identifiant d'une ligne est le champ 4, pour l'exemple précédent ça donne :

$ grep -v '(déjà attribué)' 2016.csv | cat - <(join -t',' <(tail -n +2 2016.csv | sort -k4,4 -t,) <(tail -n +2 2015.csv | sort -k4,4 -t,) -j 4 -o 1.1,1.2,1.3,1.4,2.5)
CLASSE,NOM,PRENOM,LOGIN,MOT DE PASSE
c601,Z,bob,bob.z,t954fd
c502,A,antoine,antoine.a,4f56yg
c404,B,micheline,micheline.b,654pgh

j'ai des doublons (triplons, quadru-,etc.) incompréhensibles dans mon fichier original

Tu as un exemple ? sort permet d'enlever les doublons (uniq aussi d'ailleurs)

Pour le tri :

 grep -v '(déjà attribué)' identifiants2016.csv | cat - <(join -t',' <(tail -n +2 identifiants2016.csv | sort -k2,4 -t,) <(tail -n +2 identifiants2015.csv | sort -k2,4 -t,) -j 2 -o 1.1,1.2,1.3,1.4,2.5) 
CLASSE,NOM,PRENOM,LOGIN,MOT DE PASSE
c601,Z,bob,bob.z,t954fd
c502,A,antoine,antoine.a,4f56yg
c404,B,micheline,micheline.b,654pgh

Pour la classe il faut que tu précises. Si tu as ça :

$ cat 2015.csv
c000,Z,bob,bob.z,000000
$ cat 2016.csv
c999,Z,bob,bob.z,999999

Tu es censé avoir quoi en sortie ?

Une solution possible :

$ grep -v '(déjà attribué)' identifiants2016.csv | cat - <(join -t',' <(tail -n +2 identifiants2016.csv | sort) <(tail -n +2 identifiants2015.csv | sort) -j 2 -o 1.1,1.2,1.3,1.4,2.5)
CLASSE,NOM,PRENOM,LOGIN,MOT DE PASSE
c601,Z,bob,bob.z,t954fd
c404,B,micheline,micheline.b,654pgh
c502,A,antoine,antoine.a,4f56yg

Ca te convient ?

Maintenant sur cette solution, elle me convient très bien et elle m'évite justement de gérer la création et la suppression de fichiers lock qui à mon sens est bien plus lourde mais peut-être pour toi plus déterministe => J'en conviens mais question de point de vue ;-)

Il n'y a pas de création de "fichiers lock" ;)

On verrouille tout simplement le fichier que tu veux transférer pour qu'il ne soit pas disponible pour une autre instance du script.

Note également que le verrou se déverrouille tout seul à la fin du sous shell.

Si tu veux traiter un fichier depuis ta console : worker filename

Depuis ton incrontab : dirname IN_CLOSE_WRITE worker $@/$#

Version "balai" : find dirname -print0 | xargs worker

Tu peux lancer tout ça en même temps sur le même répertoire, les fichiers ne seront traités qu'une fois. Et ça même si ton traitement évolue en terme de durée, ou si le système est fortement ralenti pour une raison ou une autre.

Et tout ça avec une dizaine de lignes en plus que ton traitement, pas de calculs bizarres ou d'estimation non déterministe. J'ai l'impression que tu préfères la tienne parce que tu n'es pas à l'aise avec les verrous. Fais des tests, tu verras c'est pas spécialement difficile à utiliser.

Voilà mon problème, j'aimerai pouvoir lancer ce script balai même quand incrond est en train de tourner. La plupart du temps, ce script ne devrait rien voir et ne pas prendre en charge de fichiers dans les dossiers de réception car incrond est très rapide et le script de dispatch est très court…

C'est de la bricole selon moi. Ca marche pour l'instant, mais pour ma part c'est pas assez déterministe pour passer en production. Qu'est-ce qui va se passer si toi (ou un de tes collègues) modifie le script de traitement pour lui faire faire une opération plus longue qu'une minute ? Ton "script balai" risque d'essayer de traiter un fichier déjà en cours de traitement par incron.

La solution à base de verrou qui t'a déjà été proposée est plus fiable. Plus courte également je pense :

#!/bin/bash

[ $# -eq 1 ] || {
        >&2 echo "Usage: ${0##*/} filename"
        exit 1
}

[ -f "$1" ] || {
        >&2 echo "'$1' not exists or is not regular file!"
        exit 1
}

(
        flock -nx 200 || {
                >&2 echo "'$1' is already being processed!"
                exit 1
        }
        printf "Processing..."
        sleep 5 && rm "$1" && printf "ok!\n"
) 200<"$1"

Si on le lance 2 fois sur le même fichier :

$ ./worker test.txt
Processing...ok!

$ ./worker test.txt
'test.txt' is already being processed!

C'est assez simple à faire avec une pfsense et plusieurs box. Je l'ai fait dans un genre de lycée loin du dslam : 4 lignes adsl orange agrégées. Ça leur permet de passer de 5/1 à 20/4 et ça change tout. Si ça vous intéresse on peut en discuter.

Tout à fait d'accord sur le principe, mais l'implémentation est mauvaise. Pourquoi tu tiens à l'écrire en 139 lignes alors qu'on peut l'écrire en 2 ?

Effectivement. Si l'écart entre les lancement doit être homogène on peut faire ceci :

0,10,20,30,40,50 0-21,23 * * * user tonscript
50 22 * * * user tonscript

139 lignes ? pour faire quoi ?

J'imagine qu'il sous entendait écrire une ligne dans la crontab par lancement. Genre :

0 0 * * * user tonscript
0 1 * * * user tonscript
...
50 21 * * * user tonscript
50 22 * * * user tonscript
...
50 23 * * * user tonscript

Si je compte bien ça fait 24 * 6 - 5 = 139.

*/10 0-21,23 * * * user tonscript
50 22 * * * user tonscript

Effectivement :

$ while IFS='#' read a b ; do echo "$a#"; done < test.txt
sssssss#
zzzzzzz#
eerreee#

$ while read; do echo $(echo "$REPLY" | cut -d# -f1)'#'; done < test.txt

On peut peut-être faire plus élégant, mais rien me vient à l'esprit.

Une autre solution si tu utilises bash :

#!/bin/bash
declare -A o
while read
do
        k=$(echo $REPLY | cut -d# -f1)
        v=$(echo $REPLY | cut -d# -f2)
        [ ${o[$k]+_} ] && o[$k]=${o[$k]}', '$v || o[$k]=$v
done < "$1"

for k in "${!o[@]}"; do echo "$k # ${o[$k]}"; done

Ca donne ça :

$ ./script1 data.txt 
titi  # TEST1, TEST2, TEST3
tata  # TEST1
toto  # TEST1, TEST2

[[ "{ancienvaleur}" ]]

Les accolades sont inutiles dans ce cas, ceci est suffisant :

[[ "$valeur" == "$ancienvaleur" ]]
end