Vendredi, j'ai parlé de l'utilisation du fichier hosts pour des objectifs beaucoup moins professionnels que ceux dont que je m'apprête à vous parler. En fait, lorsque je développe des projets personnels, j'utilise souvent mon poste de travail comme laboratoire et j'accède à mes différents projets à partir de http://localhost (127.0.0.1).

Cependant, plutôt que de créer chaque projet dans un répertoire à la racine du répertoire www d'Apache, je préfère utiliser ce qu'on appele un hôte virtuel (VirtualHost ou vhost). Je peux donc placer mes projets à différents endroits sur mon poste. Pour chaque projet, je crée ensuite un sous-domaine à localhost. Par exemple si mon premier projet est placé dans www : http://localhost/projet1/ deviendra http://projet1.localhost/. Ainsi, je peux continuer à programmer en utilisant la racine du répertoire comme référence, comme si le projet était en ligne sur son propre nom de domaine.

Voici pour configuration possible pour Apache (je baserai mon exemple en utilisant EasyPHP mais le fonctionnement reste identique si on utilise Apache seul) :

1. D'abord, je crée deux projets, le premier dans le répertoire www d'Apache, le deuxième à un autre endroit, par exemple sur la partition D:
   
2. On doit accéder au fichier httpd.conf d'Apache (C:\Program Files\EasyPHP 2.0b1\conf_files\) et s'assurer que la ligne suivante n'est pas commentée (elle ne doit pas avoir de symbole # devant) :
   
   Include conf/extra/httpd-vhosts.conf
   
   
3. Ouvrir le fichier httpd-vhosts.conf (C:\Program Files\EasyPHP 2.0b1\apache\conf\extra\) et ajouter un hôte virtuel pour chaque projet :


   NameVirtualHost *:80
   <VirtualHost *:80>
   DocumentRoot "C:\Program Files\EasyPHP 2.0b1\www\projet1"
   ServerName projet1.localhost
   </VirtualHost><VirtualHost *:80>
   DocumentRoot D:\Programmation\Web\projet2
   ServerName projet2.localhost
   </VirtualHost>
   

   Où :
   DocumentRoot est le chemin où se trouve le projet
   ServerName est le nom du serveur
   
   
4. Dans le fichier hosts (Sous XP : C:\WINDOWS\system32\drivers\etc\), ajouter une ligne pour chaque projet :
   

   127.0.0.1    projet1.localhost
   127.0.0.1    projet2.localhost
   

5. Redémarrer Apache (pour que la nouvelle configuration prenne effet. EasyPHP a un raccourci pour le redémarrer à partir du système tray)
   
6. Ouvrir un invite de commande et exécuter la commande suivante (pour que les domaines soient associés aux adresses IP spécifiées - pour notre poste seulement!) :
   
   ipconfig /flushdns
   
   
7. À partir de votre fureteur préféré, tester l'accès à http://projet1.localhost et à http://projet2.localhost. Le tout devrait maintenant fonctionner.
   

Un intellectuel est quelqu'un qui rentre dans une bibliothèque même lorsqu'il ne pleut pas.

Saviez-vous que Google tient vraiment à ce que vous l'utilisiez ?

À l'image de leur pagination de résultats de recherche, vous pouvez y accéder avec un des domaines suivants :

• gogle.com
  
• google.com
• gooogle.com

• gogole.com
• googel.com
• googil.com

• Elgoog : les résultats à l'envers
• Toogle : les résultats en image texte (impressionnant)
  

Un mauvais tour à jouer à un ami est de faire en sorte que lorsqu'il tente d'accéder à un site web populaire, il se retrouve ailleurs sans savoir pourquoi. C'est possible de le faire en modifiant le fichier hosts de son poste de travail.

Pour comprendre l'astuce, il faut savoir que lorsqu'on accède à un site web, le domaine entré est traduit en adresse IP grâce à un service nommé DNS (Domain Name System). Il est possible de modifier le fichier hosts pour y ajouter des règles de correspondance ou de les remplacer.

Dans cet exemple, je ferai en sorte que lorsqu'on voudra accéder à Google, on se retrouvera à la place chez Yahoo. Pour y arriver, on devra d'abord connaître l'adresse IP de Yahoo.

En ouvrant un invite de commande, exécuter un ping pour obtenir l'adresse IP du domane : ping www.yahoo.com

Identifier et noter l'adresse IP dans la réponse
Reply from 69.147.76.15: bytes=32 time=34ms TTL=52

Ouvrir ensuite le fichier hosts avec un éditeur texte. Sous Windows XP, il est placé dans C:\WINDOWS\system32\drivers\etc\hosts. Le même type de fichier existe sous Linux (dans /etc/hosts) mais ses utilisateurs ne sont généralement pas les cibles de ce genre d'attrapes ;-)

Sous la ligne 127.0.0.1 localhost, ajouter une ligne pour chaque domaine à remplacer sous la forme [adresse ip] [domaine] :

69.147.76.15 www.google.com
69.147.76.15 google.com
69.147.76.15 www.google.ca
69.147.76.15 google.ca

A noter que j'inclus des entrées sans les sous-domaines www car certaines personnes les omettent dans les urls, ainsi que les extensions .com et .ca afin de couvrir les principaux domaines de Google susceptibles d'être utilisés. Enregistrer le fichier et exécuter l'instruction suivante dans l'invite de commande pour réinitialiser la table de correspondance locale : ipconfig /flushdns

Normalement, ça fonctionne immédiatement (et seulement sur le poste de notre victime). Cependant, j'ai cru remarquer que certains fureteurs gardaient en cache l'information DNS et la rafraîchissait au bout de quelques minutes. Généralement, c'est assez rapide.

Lorsque votre victime (ou vous-même) tentera d'accéder au site de Google, elle attérira sur Yahoo. Autant que possible, je ne vous conseille pas de faire cette plaisanterie au bureau, à moins d'avoir la complicité de votre administrateur réseau, ou que vous occupiez vous-même ce poste. Essayez de garder un minimum de bon goût mais assurer-vous de faire durer le plaisir.

Oh, j'oubliais... Pour revenir à la normale, il suffit de retirer les entrées dans le fichier hosts et de réexécuter la commande ipconfig /flushdns.

Je viens à l'instant de revenir de la troisième édition du Startup Camp Montreal qui se tenait à la Société des Arts Technologiques. Cet événement a pour but d'aider les entreprises en démarrage à présenter leurs idées aux investisseurs, où chaque invité a droit à 5 minutes au micro pour convaincre les gens de l'audience de la pertinence de leur projet. L'assistance peut ensuite participer à un échange de conseils et d'informations pour aider les entrepreneurs à paufiner leurs présentations afin de pouvoir mieux convaincre les futurs investisseurs (VCs, angels, etc).

La soirée débuta avec une introduction de Patrick Lor (iStockPhoto.com) qui usa de son expérience pour présenter ses précieux conseils au public, jusqu'à ce que les discours des startups commencent. Les projets présentés étaient les suivants :

• SmartHippo
• Dokdok
• Tiamat Trading
• ArkaLumen

Tous les jours, quand je suis au travail, j'ai l'habitude d'écouter de la musique. La plupart du temps, j'utilise Winamp Lite pour sa légereté (très peu gourmand en mémoire) et lorsque j'ai le goût de découvrir de la musique, je vais fouiner sur iTunes dans les répertoires partagés de mes collègues. Chez moi, j'utilise 3 autres types de lecteur selon mes besoins. Je suis peut-être exigeant, mais aucun des lecteurs ne me donne entière satisfaction. Certains possèdent des fonctionnalités intéressantes, d'autres un look plus intuitif, et certains gèrent mieux que d'autres les librairies les plus larges.

Dans ma quête du lecteur idéal, j'ai découvert Songbird, un lecteur personnalisable à la manière de Firefox grâce à des extensions indépendantes. Encore en version beta, ce projet open source multi-plateforme (Windows, OS X et Linux) est développé par des membres de l'ancienne équipe de Winamp et de Yahoo! Music Engine.

En voici les grandes lignes :

• Interface graphique s'inspirant énormément de iTunes
• Possibilité d'appliquer des skins (qu'ils appelent des feathers) et de le réduire en version miniature
• Prises en charge plusieurs formats audio comme les MP3, FLAC, Vorbis, Ogg, etc.
• Support pour plus de 25 langages
• Gestionnaire de pochettes
  
• Bâti sur l'engin Mozilla XULRunner (comme Firefox), il est donc aussi un fureteur

• LyricMaster : utilise les metadatas des fichiers musicaux pour obtenir automatiquement les paroles
• MediaFlow : permet de visualiser les pochettes des albums comme dans iTunes
• iPod Device Support : pour faire le plein! Mon iPod mini est compatible mais mon iPod Touch a plus de difficulté...
• Wikipedia Extension : obtenir de l'information sur l'artiste
• Album List : un type d'affichage comme dans iTunes
• Album View : un autre type d'affichage comme dans iTunes 8, où l'on voit toutes les pochettes
• Last.fm : intégration du service pour mettre à jour son compte de profilage musical
  

Pour chaque application web ou CMS que j'ai développé, j'ai souvent eu de la difficulté à figurer de quelle façon j'allais implémenter la gestion des droits d'accès (par utilisateur, par niveau, par module et même par fonctionnalité). Malgré mes tentatives, je n'étais jamais tout à fait satisfait de l'élégance et de la lisibilité du code produit. Jusqu'à ce que je découvre Zend_Acl (Access Control List), un composant faisant parti de la librairie Zend Framework pour PHP.

Ce qui est bien avec le Zend Framework, c'est qu'il ressemble davantage à une librairie de code et de compostants plutôt qu'un framework imposant un cadre de travail prédéfini à respecter. Ça nous laisse donc la possibilité d'utiliser seulement les objets que nous avons besoins, tout en conservant nos bonnes (et parfois mauvaises!) habitudes de travail.

Pour pouvoir utiliser le composant, il faut d'abord télécharger Zend Framework (actuellement la version 1.7) et inclure les fichiers sources à son projet.

Dans un fichier php global au projet, on ajoutera les références aux objets nécessaires :

require_once('Zend/Acl.php');
require_once('Zend/Acl/Role.php');
require_once('Zend/Acl/Resource.php');

Instancier un objet ACL :

$oAcl = new Zend_Acl();

Définir les rôles :

$oAcl->addRole( new Zend_Acl_Role('programmers') );
$oAcl->addRole( new Zend_Acl_Role('designers') );
$oAcl->addRole( new Zend_Acl_Role('sysadmin') );

On spécifiera ensuite les ressources du site ou de l'application (par exemple un module ou une section) :

$oAcl->add( new Zend_Acl_Resource('internet') );
$oAcl->add( new Zend_Acl_Resource('databases') );
$oAcl->add( new Zend_Acl_Resource('zend_studio') );
$oAcl->add( new Zend_Acl_Resource('coffee') );
$oAcl->add( new Zend_Acl_Resource('photoshop') );
$oAcl->add( new Zend_Acl_Resource('servers') );
$oAcl->add( new Zend_Acl_Resource('porn') );

Pour terminer, on indiquera pour chaque module quels sont les privilèges qu'un niveau d'utilisateur a droit :

// Tous les niveaux
$oAcl->allow(null, 'internet', 'view');
$oAcl->allow(null, 'coffee', 'drink');
$oAcl->allow(null, 'porn', 'view');

$oAcl->allow('programmers', array('databases', 'zend_studio'), 'use' );
$oAcl->allow('designers', 'photoshop', 'use');
$oAcl->allow('sysadmin', 'servers', 'update');

$oAcl->deny( array('programmers', 'designers'), 'porn');

Je crois que vous avez compris, nul besoin de m'acharner puisque le code parle de lui-même. On pourra ensuite vérifier les droits aux endroits nécessaires et agir en conséquence (afficher une section, refuser l'accès, etc.) :

if ( !$oAcl->isAllowed($userLevel, 'coffee', 'drink') ) {
...
}

Avec Zend_Acl, il devient facile de faire la gestion des ressources, des rôles et des privilèges. En plus d'être facile à lire, le code se maintient très facilement. On peut ajouter de nouveaux rôles et de nouvelles ressources en un rien de temps. Exactement le genre de composant que j'aime pour être efficace dans mon travail.

Aujourd'hui, à mon travail, j'ai eu une discussion intéressante avec un autre développeur. Son OS préféré avait prit en otage la mémoire vive de son ordinateur et il avait énormément de difficulté à faire quoi que ce soit sur son poste, dont sa fonction principale, programmer. En vérifiant les processus de Windows, nous avons remarqué que l'éditeur web était en cause et que la mémoire virtuelle du processus dépassait 1 Go. En réaction à tout cela, ma matière grise s'éveilla et je me souvins d'une époque pas si lointaine où les éditeurs web étaient tellement moins gourmands. Époque dont je ne m'ennuie pourtant pas du tout...

Sur le chemin du retour, j'ai tenté de faire le compte de tous les éditeurs web que j'ai pu utiliser depuis mes premiers pas sur le web. Lorsque je suis arrivé chez moi, j'ai fouillé dans mes boîtes et à ma grande surprise, j'y ai trouvé une copie authentique du logiciel WebExpert de Visicom Media. Datant de 1997, cette petite disquette contenait la version 2.03a de WebExpert pour Windows 95 / NT 4.0 et permettait de créer des sites compatibles avec Netscape 3 et Internet Explorer 3. Et ce n'est rien! Permettez-moi de vous dire que j'avais acquis ce classique pour la modique somme de 56.32$, au défunt Aventure Électronique :-)

Selon mes souvenirs, voici la liste des éditeurs web que je me souviens avoir utilisé, en ordre chronologique :

• NotePad
• Netscape Gold (1996)
  
• WebExpert (1997)
  
• HotDog
• HoTMetaL
• SimpleWeb 1.0 (projet d'études d'un étudiant dans mes cours, vers 1999)
• Arachnophilia (2001)
  
• Allaire HomeSite (probablement la version 5, 2001)
• Dreamweaver UltraDev 4.0 / Dreamweaver 4 (2000)
  
• Dreamweaver MX (2002)
  
• Dreamweaver MX 2004 (2003)
  
• Dreamweaver 8 (2005)
  
• Eclipse / PDT (2006)
  
• Zend Studio 5.5 (2007)
  
• Zend Studio for Eclipse (2008)
  

Il y a quelques années, je me souviens avoir travaillé sur un projet ASP assez complexe qui avait nécessité l'écriture de nombreuses classes. Comme certaines classes fonctionnaient par composition d'objets, je devais inclure en entête du script principal toutes les dépendances et surtout ne pas en oublier. Parfois, un fichier en incluait un autre (à éviter) ou incluait le même qu'une autre librairie et comme ASP n'avait pas de mécanisme équivalent aux méthodes include_once() ou require_once() de PHP, certaines erreurs de redéfinitions survenaient.

En PHP 5, on a la possibilité d'utiliser une fonction nommée __autoload() qui permet, lorsqu'on déclare un objet qui n'est pas défini, de charger automatiquement la librairie reliée. Ce mécanisme permet donc d'inclure dynamiquement les librairies dépendantes lorsqu'elles sont requises, plutôt que de les inclure comme on le faisait traditionnellement en PHP 4 ou en ASP.

Dans un fichier de configuration global au projet (c'est-à-dire inclus à toutes les pages), on pourra définir la fonction qui effectuera le travail pour nous. Idéalement, on ajoutera aussi le chemin menant au répertoire des classes dans le fichier php.ini (variable de configuration include_path). Sinon, on devra spécifier le chemin d'accès aux classes à l'intérieur de la fonction __autoload().

Pour simplifier l'exemple suivant, j'ai spécifié dans php.ini le chemin du répertoire où je conserve toutes mes classes (donc transparent dans le code).

// Dans le fichier de configuration config.php
<?php
function __autoload($classname) {
    require_once($classname . '.php');
}

// Dans le fichier principal
<?php
require_once('config.php');

$obj = new DBI();

The internet is a place where absolutely nothing happens. You need to take advantage of that.

Sous Apache, il est possible de créer des redirections au niveau serveur grâce au fichier .htaccess. Cette méthode possède au moins quatre avantages :

• Permet d'éviter d'utiliser le tag <meta http-equiv="refresh"> (non recommandé)
• Avoir des règles de redirections même sur des pages HTML non dynamiques ou des répertoires
  
• Garde le code source dynamique plus "propre"
  
• Meilleure structure puisque les redirections sont regroupées dans un même fichier

• Ajouter une ligne dans le fichier en respectant la syntaxe suivante :
  Redirect 301 [ancien chemin] [nouveau chemin]
  
  Par exemple :
  Redirect 301 /Dev/ancienne_page.html /Dev/nouvelle_page.html
  
  
• La redirection fonctionnera même si l'ancienne page ou répertoire n'existe plus physiquement sur le serveur
  
• Le chemin redirigé correspond à la nouvelle adresse de la ressource, donc on peut spécifier aussi l'URL complète pointant vers un site se trouvant sur un autre domaine
• Enregistrer le fichier et l'envoyer sur le serveur
• Tester en accédant à l'ancien chemin. La redirection se fera automatiquement.

J'ai commencé à utiliser la librarie prototype.js quelque part en 2006 et dès le départ, j'ai apprécié la facilité à laquelle je pouvais écrire du code et la clareté des énoncés. Le DHTML et le Ajax étant maintenant devenus des incontournables dans des Rich Internet Applications (RIA), les programmeurs qui font aujourd'hui le saut à prototype doivent changer leurs habitudes et intégrer les nouvelles façons de faire.

Notion fondamentale de la librairie
La notation utilisée dans prototype permet d'utiliser le raccourci $ pour accéder à un élément par son id. Ainsi, les deux notations suivantes sont équivalentes :

/* Sans prototype */
document.getElementById('divContent')

/* Avec prototype */
$('divContent')

Un premier appel
Le framework de prototype met à la disposition des programmeurs plusieurs objets pratiques dont Element, qui permet de modifier directement le DOM (Document Object Model) d'une page web. Par exemple, pour cacher une portion de la page en JavaScript pur, on utilisait généralement quelque chose comme ceci :

/* Cacher l'élément */
document.getElementById('divContent').style.display = 'none';

/* Afficher l'élément */
document.getElementById('divContent').style.display = '';

Tandis que prototype nous permet d'y aller plus simplement :

/* Cacher l'élément */
Element.hide('divContent'); ou $('divContent').hide();

/* Afficher l'élément */
Element.show('divContent'); ou $('divContent').show();

Attacher des événements
Prototype permet aussi de détacher le code JavaScript initialement placé "inline" dans le code HTML. Ainsi, une fonction attachée à un événement onClick d'un bouton pourra être remplacée comme ceci:

Fonction JavaScript attachée inline dans le HTML
<input type="button" id="btn" onClick="myFunction()" />

La portion onClick="myFunction()" de l'exemple ci-dessus pourra être remplacée par une fonction attachée à l'événement click par prototype
Event.observe('btn', 'click', myFunction);

Une fois ces notions de base assimilées, le vrai plaisir commence...

Pour commencer la fin de semaine du bon pied, allons-y en humour avec le site satirique The Best Page in the Universe, un site ayant généré plus de 225 millions de visites depuis 1997 (9346 ème site le plus visité selon Alexa). Corrosif à souhait, pour des heures de plaisir.

Une façon simple de créer un environnement de développement de type WAMP (Apache, MySQL et PHP pour Windows, le terme LAMP étant son alter-ego Linux) est d'installer EasyPHP. Cet exécutable installe le tout et crée une configuration pour que ça soit fonctionnel facilement, sans se casser la tête. On accédera au serveur local par http://localhost ou http://127.0.0.1/, où les fichiers (php, html, etc) auront préalablement été déposés dans le répertoire par défaut (dans mon cas C:\Program Files\EasyPHP 2.0b1\www).

Ce qui est bien, c'est que plusieurs extensions d'Apache sont disponibles mais elles ne sont toutefois pas activées lors de l'installation. C'est le cas pour mod_rewrite, un module populaire permettant de créer des règles pour réécrire les urls. Par exemple, on pourra faire en sorte qu'un url comme :

http://www.digg.com/technology.php?popular=24hours
soit traduit par l'engin par :
http://digg.com/technology/popular/24hours

Pour activer le module mod_rewrite dans Apache, on devra modifier la configuration du fichier httpd.conf d'Apache (ce n'est pas exclusif à EasyPHP) :

• Ouvrir le fichier httpd.conf (dans le répertoire d'installation de Apache ou à partir du tray, cliquer sur l'icône EasyPHP / Configuration / Apache)
• Trouver la ligne #LoadModule rewrite_module modules/mod_rewrite.so et retirer le dièse (#) pour décommenter la ligne
• Chercher dans le fichier les instructions AllowOverride None et remplacer par AllowOverride All aux endroits nécessaires. Comme il y en a plusieurs, on pourrait tous les remplacer si on n'est pas certain. La configuration initiale de EasyPHP étant plutôt stricte, ils sont tous à "none" par défaut. Dans mon cas, je développe sur un alias, donc sa configuration se trouve à la toute fin du fichier httpd.conf (un seul changement).

Lorsque l'on surf sur le web, certains sites prennent en considération le type de fureteur utilisé pour adapter le contenu ou offrir une mise en page différente. Par exemple, c'est le cas de Google, Yahoo, Facebook et Amazon, qui offrent une mise en page adaptée lorsqu'ils détectent que le visiteur utilise un appareil iPhone (Safari). Au niveau de la programmation, ceci est rendu possible en vérifiant une propriété propre à chaque fureteur qui s'appele le "user-agent".

Si on entre la commande about:config dans la barre d'adresse de Firefox, on pourra voir le user-agent à partir de la propriété nommée general.useragent.extra.firefox dont la valeur est Firefox/3.0.4 (celui que j'utilise présentement).

Une extension de Firefox nommée User Agent Switcher permet de modifier la valeur du user-agent spéficié par le fureteur lors des visites. Pour ajouter un nouveau user-agent, il faut se rendre dans les options de l'extension, sous le menu User Agents, ajouter un nouveau type et le sélectionner dans le menu (Tools / User Agent Switcher).

Par exemple, pour visualiser un site comme le verrait un iPhone, il faut en créer un avec les information suivantes :

• Description: iPhone
• User Agent: Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en)
• App Name: AppleWebKit/420+ (KHTML, like Gecko)
• App Version: Version/3.0
• Platform: Mobile/1A542a Safari/419.3

• Description: Googlebot 2.1 (New version)
• User Agent: Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)

Lorsqu'on effectue une mise en page d'un site web, il est souvent question de savoir si on doit intégrer les données en utilisant des tableaux ou non. Lorsque vous serez dans le doute, voici un site pratique qui vous permettra de trancher sur la question.

Should I Use Tables for Layout :
http://www.shouldiusetablesforlayout.com/

Récemment, j'ai eu à travailler sur un vieux projet ASP et j'ai eu la joie de redécouvrir le serveur IIS (Internet Information Services). En développant localement, j'ai eu à effectuer certaines configurations qui ont nécessité à quelques reprises un redémarrage du serveur web. Plutôt que de procéder à chaque fois à partir du GUI, j'ai préféré utiliser un petit script batch qui me permettait de faire un redémarrage complet plus facilement (un double-click), en terminant tous les services dépendants (à l'aide de net stop). Selon la documentation de Microsoft, cette opération est nécessaire lorsque la configuration modifie le régistre de IIS et le force donc à en faire une relecture.

Dans un fichier texte, inscrire les commandes suivantes et renommer l'extension du fichier .bat.

@echo off
net stop iisadmin /y
net start iisadmin
net start w3svc
net start "FTP Publishing Service"

Deux petites remarques :

• Selon ce qui a été installé, d'autres services peuvent être ajoutés à la liste
• Pour que le script puisse fonctionner, on doit avoir le contrôle de son poste (administrateur ou droits associés)

En 1996, Hotmail fut l'un des premiers services web à offrir gratuitement l'accès à un compte de messagerie électronique à partir d'Internet. Son nom original s'écrivait HoTMaiL, en référence aux pages HTML (HyperText Markup Language) et aux courriels (mail).

L'entreprise fut acquise par Microsoft en 1997 et le service fut renommé MSN Hotmail.

En tant que lecteur assidu de Cyberpresse, j'ai remarqué il y a environ 1 mois (probablement depuis la refonte) que certains de leurs fichiers .htaccess étaient accessibles en lecture dans quelques répertoires de leur site :

• Actualité
• Arts
• Dossiers
• Sports
  
• Etc... (toutes les sous-sections dans le domaine www.cyberpresse.ca)
  

<Files ~ "^\.ht">
Order allow,deny
Deny from all
</Files>

Dans l'entreprise où je travaille, nous offrons des forfaits d'hébergement dont le prix varie en fonction de l'espace disque utilisé et de la taille de la base de données. La définition du forfait de chaque client est entré dans un outil de gestion qui est lui-même relié à la facturation. Au niveau de la base de données, l'idée était de pouvoir faire le pont entre l'espace disque actuellement occupé et la taille maximale autorisée en utilisant des fonctions système incluses dans PostgreSQL. Lorsque le quota est sur le point d'être atteint, le département de service à la clientèle peut en être informé automatiquement et effectuer un suivi avec le client pour une réévaluation de ses besoins.

Pour obtenir l'espace occupé par une base de données, on peut exécuter la commande SQL suivante :

-- Taille d'une base de données en bytes (bigint : 4472412)
SELECT pg_database_size('database_name') as database_size;

En combinaison avec la fonction pg_size_pretty, on pourra formatter la taille d'un objet de façon plus lisible :

-- Taille d'une base de données en format lisible (texte, avec unité de mesure : 4368 kB)
SELECT pg_size_pretty(pg_database_size('database_name')) as database_size;

Côté pratique, on peut aussi obtenir la taille de d'autres objets de la BD en utilisant pg_relation_size :

-- Espace occupé par une table
SELECT pg_size_pretty(pg_relation_size('public.my_table')) as table_size;

-- Espace occupé par une séquence
SELECT pg_size_pretty(pg_relation_size('public.my_table_pk_seq')) as sequence_size;

Pour tous ces appels, on peut passer comme argument le nom de l'objet ou l'oid (object identifier) puisqu'il y a une surcharge des méthodes à l'interne (overloading).

Lorsque j'étais à mes premières expériences de programmation, j'ai travaillé sur de nombreux projets comportant des sections sécurisées par un nom d'usager et un mot de passe. Les codes d'accès étaient stockés dans une base de données et à ma grande surprise, les mots de passes n'étaient jamais ou très rarement encryptés. Même si parfois le contenu à protéger ne nécessitait pas une confidentialité absolue, je persistais à croire qu'il s'agissait d'une vulnérabilité dans le processus qu'il fallait corriger. D'autre part, le code dynamique des pages web avait été créé à l'aide des wizards de Dreamweaver (horrible!), qui était propice au SQL injection (doublement horrible, même si un correctif est sorti entre temps...). Certaines techniques de SQL injection permettent de contourner les mécanismes de sécurité tandis que d'autres donnent la possibilité d'extraire le nom d'une table, des champs et les données, donc possiblement le nom d'usager et le mot de passe.

Une première approche serait d'encrypter le mot de passe en utilisant un algorithme d'encryption, par exemple MD5 ou SHA1. C'est déjà un premier pas dans la bonne direction. Cependant, si le mot de passe à encrypter était "code 18", le résultat d'hachage (hash value) serait toujours le même :

MD5 : 33165ee9ddbc4cccd441e7bdc08aa606
SHA1 : 965ecafc34288a0db4efe0d1c6cd1c9d2d0c5796

Donc en effectuant une attaque par dictionnaire ou par brute force, c'est possible de réussir à obtenir le hash correspondant au terme utilisé comme mot de passe. C'est d'ailleurs une des raisons pour laquelle on recommande d'y inclure des lettres, des chiffres et des symboles, car le terme ne fera pas parti des tentatives si on est face à un dictionary attack. Pour augmenter la sécurité d'un cran, on pourra y ajouter un "salt".

En cryptographie, un salt est une série de bits qui sont ajoutés au mot de passe pour l'altérer avant qu'il soit encrypté. Ce salt devrait être idéalement aléatoire et différent pour chaque mot de passe. Ceci aura comme avantage que deux mots de passes identiques au départ auront un hash différents à la fin. Voici un exemple qui illustre l'idée du mécanisme d'encryption :

1. Lors de la création d'un compte utilisateur, saisir le nom d'usager (unique) et le mot de passe souhaité (exemple : "code 18").
2. Générer une chaîne de caractères aléatoire d'une longueur d'au moins 8 caractères (par exemple : gxGPx$Bw). Cette chaîne servira de salt.
   
3. Prendre le mot de passe et y concaténer le salt à la fin (mais pourrait être n'importe où). Ici, si le mot de passe est "code 18", la chaîne deviendra "code 18gxGPx$Bw".
   
4. Encrypter la chaîne résultante pour obtenir le hash en utilisant MD5 ou SHA1 (ou tout autre algorithme). En utilisant SHA1, le résultat deviendra : 762c845c682521188c34af97fd06b53de3ea16e9
   
5. Enregistrer dans la base de données le nom d'usager, le salt et le hash (mais pas le mot de passe).

1. L'utilisateur entrera son nom d'usager et son mot de passe original (le salt faisant parti du mécanisme interne, il est transparent à l'usager). Attention, le mot de passe est devenu sensible à la case en raison de l'encryption!
   
2. Prendre le nom d'usager entré et vérifier si un compte existe dans la base de données.
   
3. S'il existe, récupérer le salt et le hash qui correspond à ce compte.
   
4. Concaténer le salt au mot de passe fourni lors de l'authentification.
   
5. Encrypter la chaîne résultante en utilisant le même algorithme d'encryption pour obtenir le hash.
   
6. On autorisera l'accès que si le hash résultant est égal au hash récupéré de la base de données.
   

Pour créer une base de données PostgreSQL, on peut simplement exécuter la commande SQL suivante :

CREATE DATABASE dbname;

Si le gabarit (template) n'est pas spécifié, PostgreSQL créera la nouvelle base de données en utilisant un clone de la base de données "template1" (base de données système qui n'est pas destinée à faire du développement). Tous les objets se trouvant à l'intérieur de template1 seront copiés dans la nouvelle BD. Autrement dit, il s'agit du modèle par défaut dans lequel on pourra y ajouter les langages, tables, fonctions et types qui sont généralement utilisés dans la modélisation d'un projet (c'est l'équivalent de la BD "model" sous SQL Server).

CREATE DATABASE dbname;
équivaut à :
CREATE DATABASE dbname TEMPLATE template1;

Si on préfère plutôt en créer une à partir d'un modèle vierge (sans objets), on préférera utiliser template0 (autre gabarit système existant lors de l'installation) :

CREATE DATABASE dbname TEMPLATE template0;

On pourra aussi dupliquer une base de données existante, mais attention, aucun utilisateur ne doit être connecté à la source! La copie d'une base de données de travail permettra de dupliquer la structure ainsi que les données.

CREATE DATABASE db_copie TEMPLATE db_source;

Note : L'utilisation des guillemets sera nécessaire si le nom de la base de données contient des caractères spéciaux ou des majuscules.

Ça y est... Au bureau ce matin, les employés ne parlaient que de la sortie de l'expansion de World of Warcraft. Comme je n'ai jamais vraiment été gamer, je ne comprenais pas trop le sens de la discussion, à part que certains magasins ouvraient à minuit pour accomoder les joueurs pressés à acquérir le jeu. Certaines personnes ont même pris congé pour passer leur journée à jouer. Suis-je le seul à avoir un son de cloche ici ? Tout ça pour un jeu ? On n'avait pas vu autant d'engouement depuis Monsieur Patate Optimus Prime...

Tant qu'à parodier, je vous invite à jeter un oeil à un jeu dont je suis accro : First Life, la réplique à Second Life. Faites gaffe, on y prend goût!

Il semblerait que ce soient exactement les mêmes personnes qui magasinent leurs souliers chez Yellow qui sont aussi membres à la Caisse Desjardins.

Merci, banque d'images!

Voici Cooliris (qui s'appelait autrefois PicLens), une extension pour Firefox qui permet de visualiser par le web des photos et des vidéos sous forme de diaporama en plein écran, sur un mur en 3 dimensions. Même si on pourrait douter de l'utilité d'un tel visualiseur dans nos pratiques de tous les jours, l'expérience en vaut la chandelle.

Côté programmation, Cooliris permet aussi de créer son propre diaporama pour son site web en créant un flux RSS multimédia qui pourra être visualisé en 3D par les visiteurs qui possèdent l'extension.

Sinon, il sera possible d'intégrer des diaporamas qui seront indépendants de l'extension en utilisant PicLens Lite, un autre produit gratuit de Cooliris (moyennant une petite publicité de l'entreprise). En utilisant une combinaison de Flash, de JavaScript et de RSS, on pourra obtenir un diaporama de qualité avec une prévisualisation des images (thumbnails), un rendu impeccable, un mode plein écran et la possibilité d'y placer un titre et une description. Un exemple de PicLens Lite est disponible sur le site démo EuroXSports en cliquant sur le lien Start PicLens Lite Slideshow.

Selon le site de téléchargement d'extensions de Firefox, il aurait été téléchargé plus de 7 millions de fois jusqu'à maintenant, tant sur Windows que Mac. De plus, si le hasard a fait que votre fureteur préféré est Safari ou Internet Explorer, vous êtes chanceux, une version a été pensée pour vous.

Aujourd'hui, après avoir lu sur Cyberpresse un article intitulé "JVC cesse de fabriquer les magnétoscopes VHS individuels", le titre a su inspirer à mon cerveau une chronique passionnante à propos des balises <acronym> et <abbr>. Ces balises peuvent être utilisées en HTML pour fournir la description complète d'une abréviation ou d'un acronyme, en survolant le terme par le pointeur de la souris.

Ainsi, nous pourrons apprendre la signification des termes et par nos connaissances, impressionner la famille à Noël (survoler les termes avec la souris pour que la magie s'opère!) : JVC, VHS, WYSIWYG, AJAX, HTML, PHP et DOM. Le truc est simple :

<acronym title="International Business Machines">IBM</acronym>
ou
<abbr title="Advanced Micro Devices">AMD</abbr>

Voici quelques bénéfices de l'utilisation de ces balises :

• En survolant le terme avec la souris, un joli tooltip s'affiche pour en montrer la définition
• On peut leur appliquer un style CSS de bon goût selon notre humeur ou la saison
  
• Elles favorisent le référencement et l'indexation dans les engins de recherche (SEO) mais peuvent aussi servir aux systèmes de traduction

Initialement en HTML, lorsqu'on voulait ouvrir un lien dans une nouvelle fenêtre, on devait s'y prendre comme ceci :

<a href="http://www.google.com" target="_blank">Lien vers Google</a>

Malgré que l'attribut target soit déprécié depuis le XHTML 1.0, il est encore énormément utilisé. Depuis, une alternative populaire est de le remplacer par un appel JavaScript placé sur l'événement OnClick du lien :

<a href="http://www.google.com" onclick="window.open(this.href); return false;">Lien vers Google</a>

Pourtant, il serait possible de venir attacher ces événements par programmation en utilisant une combinaison de JavaScript, de Prototype, de sélecteur CSS et de l'attribut "rel". Normalement, l'attribut rel permet de décrire la relation entre la source du document et sa ressource spécifiée dans l'ancre (attribut href). Comme il s'agira d'une relation externe, j'utiliserai la valeur "external" qui est valide pour la norme XHTML :

<a href="http://www.google.com" rel="external">Lien vers Google</a>

À l'aide de la librairie prototype.js, on attachera une fonction d'initialisation (initExternalLinks) au chargement du document. À l'aide d'un sélecteur CSS appelé par $$ (depuis prototype 1.5.1), on cherchera dans le document tous les liens qui comportent l'attribut rel="external". À chaque lien trouvé, on attachera une fonction JavaScript qui permettra de prendre le href du lien et qui l'ouvrira dans une nouvelle page :

<script language="javascript" type="text/javascript">
function initExternalLinks(selector){
  $$(selector).invoke('observe', 'click', function(e){
      if(this.href){
          window.open(this.href);
          Event.stop(e);
      }
  });
}

Event.observe(window, 'load', function(){
      initExternalLinks('a[rel=external]');
  }
);
</script>

"Je vais le menacer du doigt seulement", dit-il en le posant sur la détente.

PL/pgSQL (PL pour Programming Language) est le langage de programmation procédural le plus populaire utilisé à l'intérieur de PostgreSQL. Il permet de créer des fonctions (semblables aux procédures stockées) et des triggers en utilisant des structures de contrôle, des boucles, du SQL, etc. Sa syntaxe fait penser au PL/I et compte de nombreuses similitures avec le PL/SQL d'Oracle. À titre de comparaison, PL/pgSQL est aussi l'équivalent du T-SQL de SQL Server.

Lorsqu'on crée une nouvelle base de données, le langage PL/pgSQL n'est pas présent par défaut (à moins d'avoir créé la base de données à partir d'un template qui le possédait déjà. Sinon, le langage doit être créé pour chaque base de données). À partir de PostgreSQL 8.1, la façon la plus simple pour créer le langage est d'exécuter l'énoncé SQL suivant :

CREATE LANGUAGE "plpgsql";

Cet énoncé permettra d'omettre de spécifier les fonctions Handler et Validator puisque la version 8.1 possède une liste d'arguments prédéfinis sur lesquels il se basera pour créer le nouveau langage. Ces arguments sont inscrits dans chacune des bases de données, dans la table pg_pltemplate qui se trouve dans le schéma pg_catalog.

Autrement, il faudra procéder de façon manuelle en créant la fonction Handler qui permettra d'indiquer au système de quelle façon il devra interpréter et exécuter le code, ainsi que la fonction Validator qui s'assurera de valider la définition d'une fonction, sans toutefois l'exécuter.

CREATE FUNCTION plpgsql_call_handler() RETURNS language_handler AS
'$libdir/plpgsql' LANGUAGE C;

CREATE FUNCTION plpgsql_validator(oid) RETURNS void AS
'$libdir/plpgsql' LANGUAGE C;

CREATE TRUSTED PROCEDURAL LANGUAGE "plpgsql"
HANDLER "plpgsql_call_handler"
VALIDATOR "plpgsql_validator";

À noter qu'il est aussi possible d'écrire des fonctions pour PostgreSQL en utilisant d'autres langages comme Java, Perl, Python, Ruby, PHP, etc.

Vous avez de la difficulté à retrouver votre chemin sur la toile ?
Voici un site qui peut vous aider : www.perdu.com.

Un classique sur le web depuis des années...

Hier, j'ai mis la main sur le livre PHP in Action publié en 2007 par Manning Publications. Avant de passer la commande par Amazon, j'hésitais entre ce livre et celui de APress, PHP Objects, Patterns, and Practice, mais celui de Manning semblait pousser plus loin la question de la programmation orientée objet.

Je me suis souvent rendu compte que bien des programmeurs maitrisaient un langage mais manquaient de points de repères pour bâtir la structure d'un projet, particulièrement dans un langage comme le PHP où il n'y a pas de cadre prédéfini à respecter. Ce livre dévoile une suite de bonnes pratiques appliquées au langage PHP et même si on en retient que quelques trucs, sa lecture est inspirante et donne le goût d'élever d'un cran son niveau de programmation.

Regroupés en quatre grandes parties (Tools and concepts, Testing and refactoring, Building the web interface, Databases and infrastructure), les sujets abordés à travers les 21 chapitres de ce livre vont de la construction des classes, les interfaces, l'architecture MVC (Model-View-Controller), la composition d'objets, certains design patterns applicables (strategy, adapter, decorator, iterator, composite), le refactoring, les tests, les contrôleurs, les classes de connexion aux bases de données, l'abstraction, etc.

La plupart des livres de programmation que j'ai acheté jusqu'à maintenant étaient publiés par O'Reilly, Addison-Wesley, APress et parfois Wrox. C'est pourtant la deuxième fois que je m'en procure un de Manning (le premier étant Object Oriented Perl, il y a près de 10 ans, un secret bien gardé) et encore une fois, je suis surpris par la qualité de l'ouvrage. Il est concis, contient beaucoup d'information, les concepts sont clairement expliqués, il traite de problèmes concrets et démontre la théorie par des exemples pratiques.

Sous ma machine virtuelle Kubuntu, j'ai tenté d'activer les effets graphiques de KDE, question de voir ce qui s'y cachait. Avant de démarrer la vm de VirtualBox, j'ai pris soin d'aller dans ses settings pour lui attribuer une plus large part de mémoire vidéo (Video Memory Size). Suite au démarrage de Kubuntu et de l'identification, j'ai suivi ce chemin :

Menu K / Computer / System Settings / Onglet General / Icône Desktop / Desktop Effects / Cocher Enable desktop effects (Apply, Accept Configuration).

Comme je ne suis pas allé dans les options avancées, le type de rendu OpenGL a été choisi par défaut plutôt que XRender (qui lui fonctionne, en tout cas, mieux que pas du tout) et je suis allé trop vite pour accepter les modifications (normalement, un décompte de 10 secondes permet de récupérer automatiquement la configuration initiale en cas de problème). Comme OpenGL nécessite l'accélération 3D de la carte vidéo, VirtualBox n'est pas en mesure de le supporter car il utilise seulement une partie des composants physiques de la machine hôte.

Une fois pris avec une belle fenêtre noire X Windows, la commande CTRL+ALT+Backspace m'a permis de tuer X Windows pour revenir à la fenêtre d'identification graphique.

Pour corriger le problème, il faudra passer en mode console. Dans le MENU de l'écran d'identification graphique, choisir Console Login (ou raccourci ALT-N) et entrer le nom d'usager et le mot de passe. Lorsque l'invite de commande apparaîtra, entrer :

kwriteconfig --file kwinrc --group Compositing --key Enabled false

Ensuite, redémarrer le server X Windows avec la nouvelle configuration : startx

De retour à la normale. Pour activer plutôt les effets XRender (personne ne pourra me reprocher que c'est toujours agréable un peu de eyes candy, non ?), il faudra aussi cocher Enable desktop effects et cliquer sur Advanced Options juste au bas de la fenêtre et choisir Compositing type : XRender. Appliquer et admirer.

Parfois, il est nécessaire de protéger du contenu en ligne avec un mot de passe. Voici une solution de base qui fonctionne en ayant seulement à configurer les fichiers .htaccess et .htpasswd d'Apache.

Le fichier .htaccess (hypertext access) est un fichier texte qui permet de configurer le serveur Apache et qui est souvent utilisé pour gérer les droits d'accès, les redirections et les erreurs personnalisées. De son côté, le fichier .htpasswd est aussi un fichier texte qui contient les noms d'usagers et les mots de passe donnant accès à la ressource.

Créer un fichier .htaccess

Pour cet exemple, je définirai un répertoire à protégé, nommé "download". Il faut d'abord créer un fichier nommé .htaccess, y inscrire les règles et le placer sur le serveur. Remarquez que ce fichier n'a pas de nom, il s'agit seulement d'une extension. À l'intérieur, on y inscrira ceci :

AuthType Basic
AuthName "Nom de la section"
AuthUserFile /var/www/site/download/.htpasswd
Require valid-user

La directive AuthType Basic indique que la méthode de vérification des accès se fera à l'aide du fichier indiqué dans AuthUserFile. On indiquera aussi le nom de la section protégée dans AuthName. La dernière ligne, Require valid-user, est la condition qui doit être respectée pour avoir accès à la ressource. Autrement dit, le visiteur doit avoir une authentification valide qui correspond au nom d'utilisateur/mot de passe définit dans .htpasswd. Si elle est valide, le visiteur aura accès au répertoire "download" et son contenu. On aurait aussi pu remplacer la dernière ligne par ceci pour protéger l'accès à une page spécifique:

<files>
Require valid-user
</files>

Obtenir le chemin d'accès abolu du fichier .htpasswd

Le chemin d'accès au fichier .htpasswd doit être absolu sur le serveur (chemin complet). Plutôt que de le demander à un administrateur réseau, je préfère créer un fichier php que je place à la racine du répertoire à protéger (ainsi que le fichier .htaccess et .htpasswd), et faire afficher le chemin réel du fichier :

<?php echo realpath('.htpasswd'); ?>

En tant que geek qui s'assume, je suivrai live ce soir le dévoilement des résultats des élections américaines grâce à Google.

Sous PostgreSQL 8, il est possible de définir des nouveaux types de données permettant d'être utilisés dans les tables de la même façon que les types simples integer ou varchar. Un type composite permet de décrire la structure d'un enregistrement (row) de la même façon qu'on le ferait pour une table en combinant différents types existants. On peut ensuite utiliser ce nouveau type pour définir une colonne d'une table.

Par exemple, pour créer un nouveau type définissant la structure d'une adresse :

CREATE TYPE address AS (
   civic_number varchar,
   street_name varchar,
   local varchar,
   city varchar,
   state varchar,
   country varchar,
   zipcode varchar
);

CREATE TABLE addressbook (
   pk_file serial,
   firstname varchar(50),
   lastname varchar(50),
   address_home address
);

address_home
--------------------------------------------------------
(1835,"73rd Ave","",Medina,Washington,USA,98039)

street_name     zipcode
--------------------------------------------------------
73rd Ave        98039

Quand un cannibale mange avec un couteau et une fourchette, est-ce un progrès ?

Hier, lorsque j'ai installé Kubuntu sur la machine virtuelle, je me suis rendu compte que le mode plein écran (Host+F *) permettait de mettre à l'avant plan le OS invité mais que la résolution n'était que de 800 x 600 au maximum, laissant une marge gigantesque tout autour de la fenêtre xVM (l'affichage couvre à peine 40% de l'espace disponible sur un écran 22 pouces).

Pour y remédier :

1. Lancer la machine virtuelle et attendre le démarrage du OS
2. Dans la fenêtre xVM, choisir Install Guest Additions dans le menu Devices (il se peut que le CD-ROM soit nécessaire si la source de données n'est pas montée)
3. Lancer une console par le menu K (Applications / System / Terminal Konsole) ou par le raccourci ALT+F2, entrer Konsole et cliquer sur l'icône du même nom
4. Accéder au contenu du disque : cd /media/cdrom
   
5. Lister le contenu : ls -l
   
6. Plusieurs scripts devraient apparaitre. Il faut choisir le script à exécuter selon le OS invité, dans mon cas, ce sera VBoxLinuxAdditions-x86.run. Pour faudra l'exécuter en root par la commande sudo.
7. Exécuter le script : sudo sh VBoxLinuxAdditions-x86.run
8. Redémarrer Kubuntu pour que les modifications soient appliquées
9. Au retour, si on redimensionne la fenêtre xVM ou si on bascule en mode plein écran avec Host+F, le OS invité devrait s'ajuster automatiquement pour combler tout l'espace disponible.

1. Passer en mode plein écran (Host+F).
2. Démarrer une application au hasard dans Kubuntu, par exemple Amarok (lecteur multimédia) ou Konqueror (fureteur web).
3. Appuyer sur Host+L pour lancer le mode seamless. À la première utilisation, une fenêtre d'instructions s'affiche (à lire préférablement). Cliquer "Switch" et admirer le travail de fusion des applications Linux dans l'environnement Windows.
   

Jeudi dernier, j'ai téléchargé Kubuntu 8.10 avec pour intention de l'installer éventuellement en dual boot sur ma machine Windows XP. Par contre, je me suis dit que ça serait une belle opportunité de tenter de le lancer par virtualisation à l'aide de VirtualBox (récemment acquis par Sun Microsystems), publié sous licence GPL (donc une alternative à VMware).

Installation de VirtualBox

L'installation est plutôt simple. Il suffit de télécharger l'installateur correspondant au système d'exploitation hôte, dans mon cas VirtualBox 2.0.4 for Windows hosts (compatible pour XP et Vista). Sinon, des versions pour Mac OS X architecture Intel, Linux (sous forme de packages Debian et rpm) et Solaris sont aussi disponibles. Lancer l'installateur et compléter avec les options par défaut. Très simple.

Une fois installé, il faudra lancer VirtualBox et créer une machine virtuelle pour installer Kubuntu.

Création d'une machine virtuelle

1. Lancer VirtualBox
   
2. Pour créer une nouvelle machine virtuelle (cliquer new), indiquer un nom (dans mon cas le OS invité sera Kubuntu 8.10), un type (Ubuntu).
3. L'étape suivante permet d'allouer à la machine virtuelle une quantité de mémoire ram de base qui lui sera réservée (allons-y pour 512 Mo).
4. Il faut ensuite créer un disque dur virtuel. L'idée ici est que VirtualBox prend possession d'une partie de la partition Windows pour installer le OS invité (guest). S'il s'agit de la première utilisation de VirtualBox, la liste déroulante indiquera "no hard disk" et on devra en créer un nouveau (cliquer new). Dans mon cas, j'ai choisi un type dynamique pour que l'espace alloué au disque puisse grossir selon l'utilisation que j'en ferai. Accepter la taille recommandée du disque virtuel (8 Go). Le nouveau disque apparaît dans la liste déroulante et je termine la configuration de la machine virtuelle.

• J'ai omis de placer le CD-ROM dans le lecteur donc un message d'erreur apparaît : FATAL : No bootable medium found! System halted. Fermer la fenêtre xVM (qui ressemble à un terminal ou un invite de commande), choisir "Power off the machine" et cliquer OK. Si on redémarre la machine virtuelle (start), le wizard initial n'apparaît plus. Il faudra sélectionner la machine virtuelle, cliquer sur le bouton de droite de la souris pour faire apparaitre le menu contextuel et choisir "settings". Aller dans CD/DVD-ROM et cocher "Mount CD/DVD Drive" ou choisir la source de l'image ISO du CD sur le disque dur et cliquer OK. Redémarrer la machine virtuelle.
  
• J'ai cliqué par erreur à l'intérieur de la fenêtre représentant la machine virtuelle, le curseur est disparu et je suis coincé dans cette fenêtre. On peut revenir au OS hôte en appuyant une fois sur la touche Host (définie par la touche CTRL de droite sur le clavier).
• On peut basculer entre le mode fenêtre simple et le mode plein écran avec la combinaison des touches Host+F.