• le serveur doit pouvoir accéder à internet simplement
• le serveur doit être accessible depuis mon poste de travail (ssh, http, …)
• la configuration de virtualhosts doit être simple
• aucune connection à internet ne doit être nécessaire pour accéder au serveur depuis son IP public

Pour répondre à ces contraintes, je crée des machine virtuelles avec 2 interfaces:

• eth0 sur le NAT virtualbox
• eth1 sur le réseau privé virtuel

Il faut donc activer le réseau privé virtuel sous VirtualBox en cliquant sur « + » dans Fichiers > Paramètres… > Réseau:

Une fois l’interface crée, il faut la configurer. Dans notre cas, le réseau est 192.168.77.0 et le serveur DHCP est désacttivé:

Maintenant que ce réseau existe, il fautconfigurer notre VM pour qu’elle utilise à la fois le NAT pour l’accès internet et le réseau privé virtuel pour l’IP public locale:

Voici le fichier /etc/network/interfaces coorespondant sur la VM:

# The loopback network interface
auto lo
iface lo inet loopback

# The NATed network interface
auto eth0
allow-hotplug eth0
iface eth0 inet dhcp

# The public network interface
auto eth1
allow-hotplug eth1
iface eth1 inet static
	address 192.168.77.2
	netmask 255.255.255.0
	network 192.168.77.0
	broadcast 192.168.77.255

Le point à noter: il ne faut pas déclarer de gateway pour l’interface eth1. Tout le traffic sortant (accès à internet ou au réseau local) se fait par l’interface eth0 configurée en DHCP sur le NAT Virtualbox.

Pour gérer mes virtualhosts, la configuration se fait à 2 niveaux:

• dans le fichier /etc/hosts de ma machine hôte:

  192.168.77.2    vhost.dev

• dans le fichier /etc/hosts de ma machine virtuelle:

  127.0.1.1    vhost.dev

Maintenant, cette machine virtuelle est accessible par vhost.dev, que ce soit par SSH ou HTTP, et ce avec ou sans connection internet disponible.

Pour faciliter, le démarrage et l’arrêt de la VM, je rajoute 2 alias dans mon fichier ~/.bash_aliases:

alias start-vm='VBoxHeadless --startvm "my-vm"&'
alias stop-vm='VBoxManage controlvm "my-vm" poweroff'

Malheureusement les commandes mvn --encrypt-master-password et mvn --encrypt-password demande d’inquer le mot de passe sur la ligne de commande ce qui est peu secure puisqu’il apparaitra dans l’historique du shell.

Pour contourner ce problème, il est possible de demander au shell de demander le mot de passe pour ne pas laisser de trace dans l’historique:

read -p "Password? " pass; mvn --encrypt-master-password $pass
read -p "Password? " pass; mvn --encrypt-password $pass

Depuis la version 2.2 de maven, le ticket MNG-3401 le permet en donnant l’identifiant d’exécution default-cli:

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <id>default-cli</id>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
          <descriptorRef>project</descriptorRef>
        </descriptorRefs>
      </configuration>
    </execution>
  </executions>
</plugin>

if (stage) {
	stage.addEventListener(MonEvent.MON_TYPE, _monHandler);
} else {
	this.addEventListener(Event.ADDED_TO_STAGE, function(e:Event):void{
		stage.addEventListener(MonEvent.MON_TYPE, _monHandler);
	});
}

En effet, lors de l’inialisation des composants Flex, l’attribut stage n’est pas encore disponible.

Pourtant, il est plus simple et plus propre d’utiliser SystemManager:

systemManager.addEventListener(MonEvent.MON_TYPE, _monHandler);

Ce morceau de code ne plantera pas car systemManager est initilisé dès le lancement de l’application et est toujours présent dans les composants, contrairement à stage.

• http.proxyHost pour spécifier l’hôte
• http.proxyPort pour spécifier le port
• http.proxyUser pour spécifier le nom d’utilisateur (optionnel)
• http.proxyPassword pour spécifier le mot de passe (optionnel)

Ce qui donnerai en ligne de commande pour un proxy dont l’url est http://user:password@proxy.maboite.com:8080

~$ java -Dhttp.proxyHost=proxy.maboite.com -Dhttp.proxyPort=8080 -Dhttp.proxyUser=user -Dhttp.proxyPassword=password maClasse

Python doit être installé via l’installeur de Cygwin.

Pour installer pip, nous allons utiliser easy_install qui est fourni par setuptools (version 0.6c11 au moment où j’écris ces lignes). Pour trouver la dernière version en date correspondant à notre version de Python (version 2.6.5 fournie par Cygwin), il faut se rendre sur la page officielle.

~$ wget http://pypi.python.org/packages/2.6/s/setuptools/setuptools-0.6c11-py2.6.egg
~$ sh setuptools-0.6c11-py2.6.egg
~$ easy_install pip

Une fois pip installé, il suffit de l’utiliser pour installer virtualenv et virtualenvwrapper

~$ pip install virtualenv virtualenvwrapper

On configure notre environnement dans .bashrc:

# Python pip / virtualenv / virtualenvwrapper
export WORKON_HOME=$HOME/.virtualenvs
export PIP_VIRTUALENV_BASE=$WORKON_HOME
export PIP_RESPECT_VIRTUALENV=true
source /usr/bin/virtualenvwrapper.sh

Ensuite, tout fonctionne comme dans cet article.

Les commandes de base

Voici les commandes que j’utilise le plus:

• git commit : publie localement les changements.
• git checkout myBranch : change la branche courante pour myBranch.
• git checkout -b myNewBranch : crée la branche myNewBranch et la définie comme branche active.
• git branch : liste les branches locales.
• git branch -a : liste toutes les branches.
• git status : liste tous les changements non publiés.
• git stash :  met de côté tous les changements effectués depuis le dernier commit.
• git stash apply : restaure les changement mis de côté avec git stash.
• git log -n : liste les n derniers commits.

Le fichier ~/.gitconfig

git gère 3 niveaux de configuration:

1. Le niveau système dans /etc/gitconfig qui s’applique à tous les utilisateurs
2. Le niveau global dans ~/.gitconfig qui s’applique à l’utilisateur courant
3. Le niveau dépôt dans $GIT_REPO/.git/config qui s’applique uniquement au repository courant

Celui qui nous intéresse en l’occurrence est le niveau global.

Pour commencer, il va contenir la section user permettant de nous identifier:

[user]
name = Axel H.
email = noirbizarre@gmail.com

Pour certains projet, il pourra être intéressant de modifier ces informations d’identification.

Ces informations pourront être spécifiées directement depuis le shell:

~$ git config --global user.name "Axel H."
~$ git config --global user.email noirbizarre@gmail.com

D’autres options pourront être ajoutées, telle que la coloration:

[color]
diff = auto
status = auto
branch = auto
interactive = auto
ui = true
pager = true

ou encore des alias:

[alias]
co = checkout
ci = commit
st = status
br = branch

Avec ces alias on pourra tapper:

~$ git co mabranch
~$ git ci -m "Mon commentaire"
~$ git st

Il est possible de trouver énormément d’options à rajouter dans ~/.gitconfig sur la web, notemment sur StackOverflow, et particulièrement ce thread.

Comme d’habitude, pas de secrets, tout est dans le man.

Le fichier .gitignore

Le fichier .gitignore permet de spécifier une liste de fichiers qui ne seront jamais pris en compte par git.

Je ne referais pas la documentation officielle, mais ce qu’il faut retenir c’est:

• Les lignes commençant par # sont des commentaires
• le ! permet de prendre la négation d’un pattern
• le / en début de pattern spécifie la racine par rapport au fichier .gitignore
• le / en fin de pattern spécifie un répertoire et tous ses sous répertoires
• tous les shell glob patterns sont pris en charge

Pour une documentation complète sur gitignore, la page man reste la référence.

Il est possible de spécifier un .gitignore global, par exemple:

~$ echo "*~" >> ~/.gitignore
~$ echo "*.swp" >> ~/.gitignore
~$ echo "*.pyc" >> ~/.gitignore
~$ git config --global core.excludesfile ~/.gitignore

Cela permet d’éviter de ressaisir les fichiers qui sont toujours à exclure de git (fichiers temporaires, produits de compilation, ….).

Pour résoudre ce problème, nous allons utiliser :

• pip: un remplaçant d’easy_install bien plus complet.
• virtualenv: permet d’instancier des environnements python isolés.
• virtualenvwrapper: facilite l’utilisation de virtualenv

Installation des outils de développement

Si ce n’est déjà fait, il faut installer un environnement de développement python classique:

~$ sudo aptitude install python-setuptools python-dev build-essential

Nous installons la dernière version de pip:

~$ sudo easy_install pip

Puis nous installons virtualenv et virtualenvwrapper

~$ sudo pip install virtualenv virtualenvwrapper

Il faut maintenant configurer notre environnement en ajoutant au fichier ~/.bahrc

# Python pip / virtualenv / virtualenvwrapper
export WORKON_HOME=$HOME/.virtualenvs
export PIP_VIRTUALENV_BASE=$WORKON_HOME
export PIP_RESPECT_VIRTUALENV=true
source /usr/local/bin/virtualenvwrapper.sh

Puis nous initialisons l’environnement:

~$ mkdir ~/.virtualenvs
~$ source ~/.bashrc
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/initialize
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/premkvirtualenv
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/postmkvirtualenv
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/prermvirtualenv
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/postrmvirtualenv
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/predeactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/postdeactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/preactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/postactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/get_env_details

Nous sommes maintenant prêts à instancier notre premier environnement.

Création d’un environnement isolé

Il suffit maintenant d’utiliser la commande mkvirtualenv.

~$ mkvirtualenv --no-site-packages myenv
New python executable in myenv/bin/python
Installing setuptools............done.
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/myenv/bin/predeactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/myenv/bin/postdeactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/myenv/bin/preactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/myenv/bin/postactivate
virtualenvwrapper.user_scripts Creating /home/noirbizarre/.virtualenvs/myenv/bin/get_env_details
(myenv)~$

L’option –no-site-packages permet d’avoir une installation de python nue, c’est à dire sans aucune des dépendances python ajoutées dans l’installation courante.

Utilisation en ligne de commande

Une fois l’environnement actif, le prompt du shell est préfixé par « (nom de l’environnement) ».

Pour désactiver l’environnement, il suffit d’executer:

(myenv)~$ deactivate
~$

Pour réactiver l’environnement il suffit d’executer

~$ workon myenv
(myenv)~$

La liste complète des commandes de virtualenvwrapper est disponible ici.

Utilisation dans Eclipse/Pydev

Pour utiliser cet environnement dans eclipse avec Pydev il suffit d’aller dans Preferences > Pydev > Interpreter Python et d’ajouter l’executable python qui correspond, dans notre cas ~/.virtualenvs/myenv/bin/python.

Sur l’écran qui apparait ensuite, il ne faut selectionner que les chemin qui correspondent à notre environnement (ceux commençant par ~/.virtualenvs/myenv/).

L’environnement apparait ensuite dans la liste des environnement disponibles.

Il suffit ensuite de le sélectionner dans les préférences des projets concernés.

Utilisation de pip

Lorsque l’environnement est actif, pip s’utilise comme apt/aptitude.

# Recherche de paquets
(myenv)~$ pip search mypackage

# Installation d'un paquet
(myenv)~$ pip install mypackage

Lorsque l’environnement est inactif, il est possible de specifier à pip un environnement pour l’installation avec l’option -E:

~$ pip install -E myenv mypackage

Il est possible de dumper tous les modules installé dans un fichier:

~$ pip freeze > requirements

Puis de les recharger d’un coup dans un autre environnement:

~$ pip install -r requirements

Pour plus de détails sur l’utilisation de pip, la page officielle fait office de documentation.