 |
I use ZoneMinder for my CCTV system and Munin for network monitoring. But there is no ZoneMinder plugins for Munin, so I’ve decided to wrote theses plugins :
You can download theses plugins from the subversion repository : Enjoy and feel free to report bugs and suggest new graphs. |
This document explain how to build and load an Not eXactly C program for the Lego Mindstoms NXT Robot under Debian GNU/Linux.
Lego does not provide tools for building programs for the NXT under Linux.
I don’t like Bricxcc, because :
Ths NXC compiler can be downloaded on the Bricxcc web site. The compiler is writen in Pascal.
You need to install the FreePascal Compiler and build the compiler :
$ wget http://downloads.sourceforge.net/bricxcc/nbc-1.0.1.b34.src.tgz
# apt-get install fp-compiler fp-units-fcl fp-units-base
$ mkdir nbc
$ tar xzf nbc-1.0.1.b34.src.tgz -C nbc
$ cd nbc/nxt
$ make -f nbclinux.mak
$ ./nbc
Next Byte Codes Compiler version 1.0.1.b34 (1.0.1.34, built Thu Jun 12 21:21:22 CEST 2008)
Copyright (c) 2006, John Hansen
Use "nbc -help" for more information.
# mv nbc /usr/local/bin/
Let’s try to build and send a simple hello world program to the robot :
$ cat > hello.nxc <
TextOut(0, 0, "Hello world!");
Wait(1000);
}
EOF
$ nbc hello.nxc -O=hello.rxe
In order to send the program to the robot, you need the Talk 2 NXT program : T2N.
Warning: on amd64, you need to patch the source code.
# apt-get install g++ libusb-dev
$ wget http://www-verimag.imag.fr/~raymond/edu/lego/t2n/t2n-0.2.src.tgz
$ wget http://www.csquad.org/wp-content/t2n_amd64.diff
$ cd t2n-0.2.src
$ patch -p1 < ../t2n_amd64.diff
patching file src/usbmisc.cc
patching file src/usbmisc.h
$ make
# mv obj/t2n /usr/local/bin/
Now you can plug, turn on your NXT and send the program via the USB port.
$t2n -i
#### NXT INFOS ###############
protocol version=1.124 firmware version=1.1
NXT Name: NXT
Blutooth address: 16:53:06:37:ffffffbc:00
Blutooth signal: 0
Free user flash: 44416
$t2n -v -put hello.rxe
nxt brick found, usb initialized
testing for existing file "hello.rxe"
deleting for existing file "hello.rxe"
upload hello.rxe (376 bytes) from /goinfre
that's all folks...
That’s all folks…
Malgré tout le mal qu’il est possible de penser ou de dire sur le format de fichier CSV, celui-ci présente beaucoup d’avantages :
Mais ce format de fichier ne dispose pas d’un système de validation. Dans la plupart des cas ce sont les routines d’import / export qui prennent en charge la validation des données et de leur mise en forme.
Ce travail est pénible, répetitif et ennuyeux mais nécessaire si vous ne voulez pas qu’un fichier mal formaté ne corrompe les données de votre base.
L’objectif de cette article est de proposer une solution simple permettant la validation d’un fichier CSV en utilisant les fonctionnalités offertes par les schémas XML.
Les exemples fournis sont écrit à l’aide du language de programmation PHP5.
Votre fichier doit contenir sur la 1ère ligne, le nom de chaque cologne :
“CHANNEL”;”COMPANY”;”BVD_ID_Groupe_1″;”BVD_ID_Groupe_2″;”GENRE”;”URL”;”OTHER_URL”;”COMPETENT_AUTHORITY”
“Canal+ Film 1″;”C MORE ENTERTAINMENT AB”;”NL33268595″;”DE8330261794″;”CIN”;”http://www.canalplus.se”;”http://www.sbsbroadcasting.com/, http://www.prosiebensat1.de/”;”RTVV”
“Canal+ Film 2″;”C MORE ENTERTAINMENT AB”;”NL33268595″;”DE8330261794″;”CIN”;”http://www.canalplus.se”;”http://www.sbsbroadcasting.com/, http://www.prosiebensat1.de/”;”RTVV”
“Canal+ Film 2 Sport Weekend”;”C MORE ENTERTAINMENT AB”;”NL33268595″;”DE8330261794″;”CIN”;”http://www.canalplus.se”;”http://www.sbsbroadcasting.com/, http://www.prosiebensat1.de/”;”RTVV”
“Canal+ Film 3″;”C MORE ENTERTAINMENT AB”;”NL33268595″;”DE8330261794″;”CIN”;”http://www.canalplus.se”;”http://www.sbsbroadcasting.com/, http://www.prosiebensat1.de/”;”RTVV”
“Canal+ Film HD”;”C MORE ENTERTAINMENT AB”;”NL33268595″;”DE8330261794″;”CIN”;”http://www.canalplus.se”;”http://www.sbsbroadcasting.com/, http://www.prosiebensat1.de/”;”RTVV”
Pour transformer le fichier CSV en XML, il suffit de lire le fichier CSV avec la fonction fgetcsv et mettre les données dans des balisent XML : csv_to_xml.php
Une fichier CSV converti en XML ressemble à cela : channel.xml
Il ne reste plus qu’à écrire le schéma permettant de valider le fichier XML : channel.xsd
Vous pouvez tester vos schéma en ligne de commande en utilisant la commande xmllint issue du paquet Debian libxml2-utils :
$ xmllint --noout --schema channel.xsd channel.xml
channel.xml validates
Une fois que votre schéma est correct et permet de valider le contenu du fichier XML, il faut l’intégrer directement dans votre application : validate.php
Cette méthode apporte les avantages suivants :
Cette technique a été mise en oeuvre dans le cadre du projet MAVISE pour valider plus d’une vingtaine de formats de fichiers différents.
Il existe des outils tel que SQLSync permettant de synchroniser les données d’une base PostgreSQL. Mais cette outil, ne permet pas de faire une copie partiel des données.
Dans la plus part des cas, il faut programmer la synchronisation soit même, l’objectif de mon article est de vous proposer une solution simple et élégante.
 |
Des données sensibles se trouvent dans la base principale et il ne faut synchoniser qu’une partie de ces données vers les autres bases.
L’architecture dispose des caractèristiques suivantes :
|
Pour résoudre le problème, j’ai testé plusieurs approches avant de retenir l’utilisation d’un fonction de hachage dont voici le principe :
Le calcul de la somme de hachage se fait un niveau de la base de données à l’aide d’un fonction :
SELECT id,md5 FROM get_table_md5('nom_de_la_table');
id | md5
----+----------------------------------
4 | 9f3bcd2fae528244669613ae0466cc3c
5 | 1f3bcd2fa24528244669613ae66cc3czd
...
(42 row)
Voici le code de la function PL/Perl:
CREATE LANGUAGE plperl;
CREATE TYPE table_md5 AS (id INTEGER, md5 TEXT);
CREATE OR REPLACE FUNCTION get_table_md5(varchar) RETURNS SETOF table_md5 AS $$
my ($rv, $status, $nrows, $row);
# Get Table OID
$rv = spi_exec_query(\"SELECT c.oid AS oid FROM pg_catalog.pg_class c
LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
WHERE c.relname LIKE '$_[0]';\");
$status = $rv->{status};
$nrows = $rv->{processed};
return undef if ($nrows != 1);
my $oid = $rv->{rows}[0]->{oid};
# Get Table attributs
$rv = spi_exec_query(\"SELECT attname,atttypid FROM pg_catalog.pg_attribute a
WHERE a.attrelid = $oid AND a.attnum > 0 AND NOT a.attisdropped\");
$status = $rv->{status};
$nrows = $rv->{processed};
return undef if ($nrows < 1);
my $atts;
my $atts_not_null;
foreach my $rn (0 .. $nrows - 1) {
if ($rv->{rows}[$rn]->{atttypid} == 16) {
$atts .= ” (CASE WHEN $rv->{rows}[$rn]->{attname} THEN ‘t’ ELSE ‘f’ END) AS $rv->{rows}[$rn]->{attname}”;
} else {
$atts .= ” $rv->{rows}[$rn]->{attname}::text”;
}
$atts_not_null .= ” (CASE WHEN $rv->{rows}[$rn]->{attname} IS NULL THEN ‘’ ELSE $rv->{rows}[$rn]->{attname} END)”;
$atts .= ‘,’ if ($rn != $nrows - 1);
$atts_not_null .= ‘ || ‘ if ($rn != $nrows - 1);
}
# Calc MD5
my $sql = “SELECT id, MD5($atts_not_null) AS md5 FROM (SELECT $atts FROM $_[0]) AS $_[0];”;
$rv = spi_exec_query($sql);
$nrows = $rv->{processed};
foreach my $rn (0 .. $nrows - 1) {
return_next({
id => $rv->{rows}[$rn]->{id},
md5 => $rv->{rows}[$rn]->{md5}
});
}
return undef;
$$ LANGUAGE plperl;
Pour utiliser cette fonction vous avez besoin du support du language de programmation PL/Perl dans Postgres, celui-ci se trouve dans le paquet Debian : postgresql-plperl-
Le choix des données à synchroniser se fait individuellement pour chaque table à l’aide de la clause WHERE de la manère suivante :
SELECT id,md5 FROM get_table_md5('nom_de_la_table') WHERE id IN(SELECT id FROM nom_de_la_table WHERE nom_de_la_table.champ LIKE 'sync');
id | md5
----+----------------------------------
1 | fdd56eabd4bb997e453e33f0022d46c1
(1 row)
La synchronisation des données peut être réalisée à l’aide de n’importe quel language de programmation,
il suffit juste de disposer d’un accèss à la base de données.
Voici un exemple de script écrit par Emmanuel Saracco en PHP5 qui se repose sur les modules PEAR suivants :
Ce script nécessite un fichier de configuration, en voici un exemple.
Ce fichier contiens la configuration des diffèrentes base de données et les conditions sous-forme de clauses where.
Cette méthode de synchronisation fonctionne, elle est en production chez un client pour une base de données de plus de 100 tables, elle permet de synchronisé le contenu d’une base vers deux autres.
Les avantages de cette méthode sont les suivants :
Tous les documents disponibles dans la partie publication de mon site web, sont écrit à l’aide du langage DocBook,
cette méthode permet de séparer fond du document de sa mise en forme et ainsi publier le document dans plusieurs formats (HTML, PDF, Texte, etc…).
Cette possibilité forte intéressante, est devenus au fils du temps un handicape.
Car la moindre modification d’un document nécessite la régénération des différents formats d’export.
J’ai donc cherché à simplifié et automatisé la procedure de publication. La résultat de ce travail est décrit dans ce document :
Je vous passe l’ensemble de la propagande habituelle sur les Web Services ( l’architecture SOA, Annuaires de services, SOAP, etc…).
Pour ma part, je pense qu’il existe deux grandes familles de WebServices :
Pour la première famille, l’ensemble des techniques disponibles (SOAP, WSDL, UDDI) couvrent les besoins.
Quant à la seconde famille, je trouve que ces techniques sont bien trop complexes à mettre en oeuvre.
Imaginons que vous avez besoin de mettre à disposition le contenu d’une base de données relationnelles ( liste de contacts, tickets, commandes en cours, etc. ) à l’aide d’un Service Web.
1/ Solution envisagée : le développement d’une Interface SOAP spécifique à votre problèmatique
Le développement de celle-ci sera long, car il vous faudra :
2/ Solution envisagée : adopter la méthodologie REST
J’ai découvert cette méthodologie suite à un article du journal du Net : SOAP, XML-RPC et EST : différences et intérêts
Elle est spécifiée dans le mémoire de Roy Thomas Fielding : Architectural Styles and the Design of Network-based Software Architectures
Ce qui est remarquable dans cette méthodologie, c’est :
Par la suite, j’ai découvert le projet PHP REST SQL, celui-ci permet de mettre à disposition le contenu d’une base de données MySQL via une interface Web.
Ce projet consiste en une classe, qui s’interface avec une base de données MySQL et qui permet à l’aide de requêtes HTTP de récupèrer les données de la base, créer, modifier et supprimer des champs.
Actuellement, le projet ne supporte que les bases de type MySQL, j’ai donc réécrit la classe pour prendre en comptes toutes les bases de données supportées par le module PEAR MDB ( MySQL, PostGreSQL, Oracle, Frontbase, Querysim, Interbase/Firebird, MSSQL et SQLite).
J’ai testé son fonctionnement avec 3 bases (MySQL, PostGreSQL et SQLite).
Cette contribution est disponible sur SourceForge : database abstraction (MySQL, Postgres and SQLite Support).
Installer et mettre en oeuvre le classe, il suffit de :
1/ Télécharger la classe :
$ wget 'http://sourceforge.net/tracker/download.php?group_id=126371&atid=705494&file_id=180054&aid=1498241' -O php_rest_sql.tar.gz
2/ L’extracter dans votre arborescence Web :
tar xzvf php_rest_sql.tar.gz -C /var/www
3/ Editer le fichier de configuration phprestsql.ini.
4/ Editer un fichier .htacces et activer le module rewrite dans Apache.
Et voila !
Vous pouvez accéder au contenu de votre base de données directement à l’aide d’un navigateur.
Il ne vous reste plus qu’à écrire un client pour accéder aux données, à l’aide de la bibilothèque PHP CURL par exemple.
J’ai soumis mon patch à Paul James, l’auteur du projet et proposé l’idée de transformer celui-ci en module Pear. Il faut savoir que l’auteur a développé le project Tonic autour du même concept.
Mais il s’agit d’un veritable framework de développement web et qui par conséquent est beaucoup plus intrusif.
Parinux a organisé une confèrence technique sur la réalisation de clients riches avec XUL, cette confèrence a été présentée par Paul ROUGET de XULFr avec la participation de deux invitées.
Pour ne pas changer les bonnes habitudes, nous sommes arrivés dans la salle avec près d’une demi-heure de retard, les causes de ce retard ne sont pas toutes avouables ( Jesse, je t’avais dit d’imprimer le plan avant de partir … Karim, l’adresse est le 85bis rue Ménilmontant et non 185, merci pour la marche à pieds ;-0 )
Visiblement les trois quarts du public était composé d’Epiteens, assez jeune donc et la salle été presque pleine (avec environ moins de 40 personnes).
Les démonstrations ont mis l’accent sur les aspects graphiques et les possiblités offertes par la plate-forme Mozilla : telles que l’intègration du format SVG et l’utilisation de plugins de rendu graphique.
Mais les plus beaux effets graphiques ont été réalisées à l’aide de plugins externe et non de l’API de Mozilla, à cause des difficutlés pour obtenir un “handle” sur le buffer d’affichage. Cette difficulté vient du fait que Mozilla est muli-plateforme est le rendu graphique se fait de manière diffèrentes en fonction de la plate-forme.
La modularté de la plate-forme offre la possiblité d’intégrer rapidement des applications exterieures, grâce aux overlay et au système de plugins (le même système que Firefox).
Biensur comme toute démonstration, il y a eu quelques accros mais dans l’ensemble les possiblités offertes sont impressionnantes.
Les deux points forts de ces applications sont la portabilité et la facilité de developpement.
Dans la période actuelle, la portablité de l’application est quelque chose de très important compte tenu, de l’hétérogénité des parcs informatiques. De nombreuses entreprises disposent d’architecture hétérognène et la plate-forme Mozilla met à leur disposition un environnement de développement modèrne et portable.
Paul a fait des comparaisons interessantes avec la technologie concurrente XAML, qui ne sera jamais hétérogène est ne fonctionnera que sur des systèmes Microsoft. Il est difficile d’imaginer l’installation d’une nouvelle carte graphique dans une station Sun pour faire fonctionner une application métier ;0)
J’ai aussi beaucoup apprécié l’honnêteté sur la difficulté d’apprentisage de la plate-forme. En effet la courbe d’apprentisage pour arriver à ce niveau est assez longue, car contrairement à d’autres technologies, il ne suffit pas d’apprendre un langage de programmation et un framwork pour obtenir des resultats intéressants, mais plusieurs technologies (XUL, CSS, XBL, XPFE, XPCOM, RDF et le langage C++) pour commancer obtenir un résultat “sexy”.
A toute l’equipe de XulFR pour leur proseitisme et à Parinux pour l’organisation.
 |
Cela fait près d’un an et demi que j’utilise le logiciel Cacti pour monitorer l’activité réseau. Aussi bien dans le cadre de mon activité professionnelle que pour mon usage personnel. Mais j’ai récement découvert une alternative sérieuse : Munin. Celui-ci présente de nombreux avantages par rapport à Cacti et mérite d’être plus connue. |
A première vue, Cacti semble être le logiciel de monitoring réseau parfait, le rendu graphique est vendeur, l’installation et la prise en main est simple. Mes principales reproches concernnent la configuration des graphiques personnalisers, que je trouve beaucoup trop complexe. Effectiffment après avoir configuré les graphiques basiques ( utilisation processeur, mémoire, disque etc… ), il est très difficile d’ajouter ses propres graphiques. Cette partie du logiciel est bien trop complexe, les nombres d’extensions disponibles est trop faible et il faut par conséquent passer beaucoup de temps sur la personnalisation des graphiques. C’est pour cela qu’après avoir installer Munin, je regrette de ne pas l’avoir découvert plutôt, cela m’aurait économisé quelques heures de sommeil précieuses ;0)
 |
Fonctionnalités: |
Une démonstration des fonctionnalité du logiciel est disponible à l’adresse suivante : http://munin.ping.uio.no/
Le serveur est décomposé en deux paquets dans Debian :
Pour l’installation d’un serveur minimal vous avez besoin d’installé le paquet munin (l’installation du paquet munin-node sera nécessaire dans le cas où vous voulez monitorer une machine à l’aide du protocole SNMP).
#aptitude install munin munin-node
L’ensemble des fichiers de configuration se trouve dans le répertoire /etc/munin:
Le processus de récupèration des données est réalisé par la commande munin-cron toutes les 5 minutes :
*/5 * * * * munin if [ -x /usr/bin/munin-cron ]; then /usr/bin/munin-cron; fi
Pour monitorer une machine, il suffit d’ajouter une entrée dans le fichier de configuration du serveur ( munin.conf ) :
[host.domain.name]
address 192.168.42.42 # l’adresse IP ou le nom DNS de la machine
Pour activer l’accés à l’interface web pour visionner les statistiques, il faut rendre le répertoire /var/www/munin accessible à l’aide du serveur Web Apache :
munin:/etc/apache/conf.d# cat munin.conf
<virtualhost munin>
ServerName munin.csquad.lan
ServerAlias munin.csquad.lanErrorLog /var/log/apache/munin/error.log
CustomLog /var/log/apache/munin/access.log commonDocumentRoot /var/www/munin
</virtualhost>
Sur chaque client, il suffit d’installer le paquet munin-node :
#aptitude install munin-node
Modifier les régles d’accès dans le fichier de configuration /etc/munin/munin-node.conf :
allow ^192\.168\.42\.21$ #adresse du serveur
L’ensemble des services disponibles sur la machine sont détectés par la commande munin-node-configure :
# munin-node-configure –suggest | grep yes
cpu | no | yes
df | no | yes
df_inode | no | yes
entropy | no | yes
exim_mailqueue | no | yes
exim_mailstats | no | yes
forks | no | yes
if_ | no | yes +eth0 +eth1
if_err_ | no | yes +eth0 +eth1
interrupts | no | yes
…
Le paquet debian, active les plugins pour les services détectés en créant les liens dans le répertoire /etc/munin/plugins :
$ ls -l /etc/munin/plugins
lrwxrwxrwx 1 root root 28 Feb 20 18:14 cpu -> /usr/share/munin/plugins/cpu
lrwxrwxrwx 1 root root 27 Feb 20 18:14 df -> /usr/share/munin/plugins/df
…
Vous pouvez désactiver un plugin en supprimant son lien symbolique et l’activer en créant un lien symbolique :
# ln -s /usr/share/munin/plugins/apache_volume /etc/munin/plugins/
Simple, non?
Après plusieurs mois de travail sur la personnalisation de cet outils pour un client, j’ai le plaisir de vous presenter un article qui décrit notre travail.
Mais tout d’abord une rapide présentation du logiciel.
RT est un logiciel libre de gestion d’incident, en anglais ticketing, il permet la prise en charge des demandes client. Lorsqu’un problème survient chez un de nos clients (plantage serveur, coupure de service, etc…) celui-ci envoie un mail ou bien téléphonne au support pour signaler l’incident.
Cet incident donne lieu à un ticket qui sera pris en charge par le support technique.
Grace à ce système :
Nous utilisons ce système chez Easter-eggs depuis près de 3ans avec succés et nous en sommes très content, comme beaucoup d’autres.
La mise en place de système est assez complexe et nécessite de bonnes compétances en administration système et en programmation Perl ( si vous voulez modifier l’outils pour l’adapter aux besoins spécifiques de votre entreprise).
Pour vous aider dans l’installation de l’outil, un article est paru dans le Linux Magazine France de ce mois-ci (Février 2006), mais celui-ci ne parle pas de la personnalisation de l’outils.
L’Application de Suivi Qualité développée par Easter-eggs à partir de RT offre la possibilité de :
Mon article est disponible au format PDF à l’adresse suivante :
The sqlite_fetch_object function is not implemented in the PECL extension version 1.0.3.
I’ve rewrite it sqlite_fetch_object in PHP :
// An empty class
class bidon {
}
// Fetch resultset as an object
function sqlite_fetch_object(&$resource){
$arr = sqlite_fetch_array($resource);
$obj = new bidon();
foreach ($arr as $key => $value) {
# Check is valid $T_VARIABLE
if (ereg(\"[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*\", $key)) {
$obj->$key;
}
}
return $obj;
}
Voila
Powered by WordPress