Pixels Cookers, un thème qui a de la gueule

C’est pour moi le thème le plus aboutit et le plus moderne. J’ai nommé Pixel Cookers, de la société du même nom. Son installation est simplissime et décrite sur le site web dédié, mais je vais en faire un résumé adapté à notre situation.

redhub:~ admin$ sudo su - redmine
redhub:~ redmine$ cd redmine
redhub:redmine redmine$ git clone git://github.com/pixel-cookers/RedmineThemePixelCookers.git public/themes/PixelCookers

Redmine Pastebin, clonons Gist tant qu’à faire !

Dans notre aventure consistant à obtenir un clone le plus complet possible de GitHub, il serait dommage d’oublier Gist. En fait, c’est plus exactement Pastebin que nous allons copier, afin que les participants de vos projets puissent s’échanger facilement des extraits de code/documentation/que sais-je…

redhub:redmine redmine$ script/plugin install git://github.com/zoc/redmine_pastebin.git
redhub:redmine redmine$ RAILS_ENV=production rake db:migrate_plugins
redhub:redmine redmine$ kill -USR2 $(cat shared/pids/unicorn.pid)

Comme vous pouvez le noter, j’ai forké le dépôt officiel du plugin, car la version initiale n’est actuellement pas compatible avec la version trunk/1.4 de Redmine. A noter également que la dernière ligne a pour effet de relancer unicorn, et par conséquent recharger Redmine, étape nécessaire pour pouvoir utiliser le plugin.

Redmine Time Tracker, gardez le contrôle du temps

Redmine dispose de fonctionnalités permettant de gérer, estimer, contrôler le temps passé sur les différentes étapes d’un projet. Redmine Time Tracker, améliore ces fonctionnalités: Là où le développeur devait saisir le temps passé à travailler sur le projet, Redmine Time Tracker va mesurer ce temps à sa place et automatiser la saisie de ces informations.

redhub:redmine redmine$ script/plugin install git://github.com/delaitre/redmine_time_tracker.git
redhub:redmine redmine$ RAILS_ENV=production rake db:migrate_plugins
redhub:redmine redmine$ kill -USR2 $(cat shared/pids/unicorn.pid)

Redmine Gitolite, L’intégration parfaite

Nous allons terminer cet article avec l’installation du plugin Redmine Gitolite. Son rôle est de permettre l’intégration parfaite de notre serveur Gitolite dans Redmine. Grâce à lui, la création d’un projet Redmine pourra entrainer la génération automatique d’un dépôt git associé, ainsi que la gestion des droits d’accès à ce dépôt.

Commençons par l’installation proprement dite

redhub:redmine redmine$ script/plugin install git://github.com/ivyl/redmine-gitolite.git
redhub:redmine redmine$ bundle install
redhub:redmine redmine$ RAILS_ENV=production rake db:migrate_plugins

Le plugin va se connecter au serveur Gitolite (qui dans notre cas est sur la même machine que Redmine, mais ce pourrait ne pas être le cas) en utilisant SSH et une authentification par clé publique/privée. Nous allons dans un premier temps effectuer une connexion SSH depuis le shell avec l’utilisateur « redmine », cette connexion ayant pour seul but d’accepter le certificat (donc répondez « yes » à la question posée suite à l’exécution de la commande ci-dessous)

redhub:redmine redmine$ ssh redhub.local ## Accepter identification host
^D

Nous avons ensuite besoin d’une paire de clés pour l’utilisateur « redmine » (qui, je le rappelle, est l’utilisateur qui fait tourner unicorn, et donc Redmine, et donc le plugin). on copie la clé publique obtenue dans un endroit facile d’accès, on configure l’identité du compte redmine vis à vis de git, puis on retourne à notre compte administrateur

redhub:redmine redmine$ ssh-keygen -n "redmine@redhub.local"
Generating public/private rsa key pair.
Enter file in which to save the key (/usr/local/share/redmine/.ssh/id_rsa):
Enter passphrase (empty for no passphrase): # Pas de passwrd
Enter same passphrase again:
Your identification has been saved in /usr/local/share/redmine/.ssh/id_rsa.
Your public key has been saved in /usr/local/share/redmine/.ssh/id_rsa.pub.
The key fingerprint is:
3a:4a:1d:09:d5:70:4d:6c:22:40:45:c6:42:22:4f:06 redmine@redhub.local
The key's randomart image is:
+--[ RSA 2048]----+
|E.+o+=*o.+.      |
| = ..oo.o +      |
|  . .. . o       |
|     . .         |
|      o S        |
|     . o         |
|    . +          |
|   . . .         |
|    .            |
+-----------------+
 
redhub:redmine redmine$ cp ../.ssh/id_rsa.pub /tmp/redmine.pub
redhub:redmine redmine$ git config --global user.email "redmine@redhub.local"
redhub:redmine redmine$ git config --global user.name "Redmine Gitolite"
redhub:redmine redmine$ logout

De retour sur notre compte administrateur, nous allons ajouter l’utilisateur « redmine » à la liste des administrateurs du serveur Gitolite, ainsi que sa clé publique (je rappelle que le nom du fichier contenant la clé publique correspond au nom d’utilisateur Gitolite). Pour cela, on clone le dépôt « gitolite-admin.git », on ajoute la clé publique, et on modifie les droits d’accès au dépôt « gitolite-admin ». Enfin, on pousse le tout vers le serveur.

redhub:~ admin$ git clone ssh://git@redhub.local/gitolite-admin.git
redhub:~ admin$ cd gitolite-admin/
redhub:gitolite-admin admin$ cp /tmp/redmine.pub keydir/
redhub:gitolite-admin admin$ git add keydir/redmine.pub

Editez ensuite le fichier « conf/gitolite.conf » et ajoutez l’utilisateur « redmine » à la liste des utilisateurs ayant un droit d’accès en lecture et écriture au dépôt « gitolite-admin ». Le contenu du fichier devrait ressembler à cela:

repo gitolite-admin
    RW+     =   admin redmine

On pousse ensuite les modifications vers le serveur.

redhub:gitolite-admin admin$ git add conf/gitolite.conf
redhub:gitolite-admin admin$ git commit -m "Adding redmine user as an administrator"
redhub:gitolite-admin admin$ git push

Pour son fonctionnement, le plugin va avoir besoin d’une copie de chaque dépôt git sous sa responsabilité, et ce même si le serveur Gitolite et le serveur Redmine sont sur la même machine (c’est bête je sais, mais c’est comme ça…). On va donc dédier un emplacement pour cet usage, emplacement qui appartiendra à l’utilisateur « redmine ».

Comme je l’ai expliqué dans mon premier article, j’ai l’habitude de stocker toutes les données « serveur » dans /Library/Server.

redhub:gitolite-admin admin$ sudo mkdir /Library/Server/RedmineRepos
redhub:gitolite-admin admin$ sudo chown redmine:redmine /Library/Server/RedmineRepos/

Enfin, il nous reste à installer un « hook » coté serveur Gitolite, « hook » dont le but est de notifier Redmine de toute modification effectuée sur un dépôt git. Pour que cela fonctionne, vous devez tout d’abord, dans Redmine, autoriser l’accès distant à la gestion des dépôts et générer une clé permettant cet accès. Pour cela, il suffit de se rendre dans les paramètres de Redmine (Settings / Administration / Onglet Repositories):

Enable WS for repository management

On peut maintenant installer le « hook », éditer sa configuration et notifier Gitolite de sa présence:

redhub:gitolite-admin admin$ sudo su - git
redhub:~ git$ cp /usr/local/share/redmine/redmine/vendor/plugins/redmine-gitolite/contrib/hooks/post-receive-redmine_gitolite .gitolite/hooks/common/post-receive
redhub:~ git$ chmod +x .gitolite/hooks/common/post-receive

Editez le fichier « .gitolite/hooks/common/post-receive ». Les paramètres de configuration se situent en haut du fichier, et devraient après édition ressembler à ceci (remplacez la clé par celle que vous avez générée précédemment et l’adresse du serveur par l’URL complète de votre installation Redmine):

#!/bin/sh
 
HOOK_URL=gitolite_hook
FETCH_URL=sys/fetch_changesets
LOG=/Library/Server/Gitolite/.gitolite/logs/post-receive.log
 
DEFAULT_REDMINE_KEY=v62Gfs0KCjeK5nvTd3F2
DEFAULT_REDMINE_SERVER=https://redhub.local/redmine
DEFAULT_REDMINE_PROJECT_ID=$GL_REPO
DEFAULT_CURL_IGNORE_SECURITY_CFG="true"

Avant dernière étape, relancer Redmine afin qu’il prenne en compte la présence de notre nouveau plugin.

redhub:~ git$ logout
 
redhub:~ admin$ sudo launchctl unload /Library/LaunchDaemons/com.zoccolo.redmine.plist
redhub:~ admin$ sudo launchctl load /Library/LaunchDaemons/com.zoccolo.redmine.plist

Il ne reste plus qu’à aller configurer le plugin directement depuis l’interface de configuration de Redmine (Settings / Administration / Plugins). Adaptez ma configuration (voir copie d’écran ci-dessous) à votre propre installation.

Nous avons maintenant (certains diront « enfin ») atteint notre but: Avoir un applicatif de gestion de projet complet et performant. J’espère avoir été assez complet.

Redmine est une application web écrite en Ruby, à l’aide du framework Rails. Apple utilise également Rails & Ruby pour son gestionnaire de profils, et c’est là que les problèmes commencent: Redmine et DeviceManager ont besoin de versions différentes de packages Ruby (appelés « gems »).

Si, comme moi, vous vous êtes déjà amusé à installer des gems supplémentaires et mettre à jour les gems fournis avec le système, vous avez sans doute remarqué que vous aviez définitivement cassé le gestionnaire de profils (et en ce qui me concerne, je n’ai pas trouvé d’autre solutions que de réinstaller Lion Server pour le réparer). Installer Redmine sur Lion Server se transforme en challenge intéressant (alors que son installation sur un autre Unix est généralement une formalité).

Dans ce guide, je vais donc proposer une installation de Redmine qui utilisera son propre environnement Ruby et Rails. Ainsi, pas de risque de dégâts collatéraux avec les applications systèmes. Mais rassurez vous, vous n’aurez (presque) aucune compilation compliquée à effectuer. Grâce à un outil « magique », j’ai nommé « rvm » (Ruby Version Manager), quelques lignes de commandes suffiront. Rvm est souvent décrit comme l’outil de packaging qui manque à Ruby.

Je me suis également fixé un autre but: Installer le moins de packages tiers possible, et éviter les modifications de fichiers de configuration existants. Au final, mon installation de Redmine respectera les contraintes suivantes:

1. Aucune interaction avec Ruby et les gems « système ». Facile en utilisant « rvm ».
2. Pas d’installation d’applications supplémentaires: On utilisera donc PostgreSQL, fourni avec le système, au lieu d’installer MySQL.
3. Pas de « bidouillage » des fichiers de configuration d’Apache: On développera donc une « webapp » à la sauce Apple: Redmine fonctionnera dans son environnement protégé (avec un utilisateur/groupe dédié), à l’aide d’Unicorn, un serveur Web léger et performant écrit en Ruby, Apache agira en tant que proxy vers ce serveur (pour info, c’est également de cette façon que fonctionne le gestionnaire de profils, Apple ayant fait le choix de Thin au lieu d’Unicorn).

Un petit mot à propos d’Unicorn: Je l’ai préféré à Thin car contrairement à ce dernier, Unicorn gère automatiquement le « Load Balancing » entre plusieurs instances de l’application Ruby et est capable de monitorer, voir relancer automatiquement ces instances en cas de plantage. Apple a résolu ces problème en développant son propre script Ruby (voir par exemple /usr/share/devicemgr/backend/devicemgrd).

C’est parti !

On commence, comme lors du précédent guide, pas la création d’un compte utilisateur « redmine ». c’est sous ce compte que le serveur Unicorn fonctionnera:

redhub:~ admin$ sudo dseditgroup -q -o create redmine
redhub:~ admin$ MAXID=$(dscl . -list /Users UniqueID | awk '{print $2}' | sort -ug | tail -1)
redhub:~ admin$ USERID=$((MAXID+1))
redhub:~ admin$ sudo dscl -q . -create /Users/redmine UniqueID $USERID
redhub:~ admin$ sudo dscl -q . -create /Users/redmine RealName "Redmine Server Account"
redhub:~ admin$ sudo dscl -q . -create /Users/redmine PrimaryGroupID $(dscl -q . -read /Groups/redmine PrimaryGroupID | awk '{print $2}')
redhub:~ admin$ sudo dscl -q . -create /Users/redmine Password \*
redhub:~ admin$ sudo dscl -q . -create /Users/redmine NFSHomeDirectory /usr/local/share/redmine
redhub:~ admin$ sudo dscl -q . -create /Users/redmine UserShell /bin/bash
redhub:~ admin$ sudo dscl -q . -delete /Users/redmine AuthenticationAuthority
redhub:~ admin$ sudo dscl -q . -delete /Users/redmine PasswordPolicyOptions
redhub:~ admin$ sudo dscl -q . -delete /Users/redmine dsAttrTypeNative:KerberosKeys
redhub:~ admin$ sudo dscl -q . -delete /Users/redmine dsAttrTypeNative:ShadowHashData
redhub:~ admin$ sudo dscl . -append /Groups/_postgres GroupMembership redmine
redhub:~ admin$ sudo mkdir -p /usr/local/share/redmine
redhub:~ admin$ sudo chown redmine:redmine /usr/local/share/redmine

Quelques remarques supplémentaires: J’ai décidé d’installer Redmine dans le répertoire /usr/local/share/redmine. De plus, j’ajoute le compte utilisateur « redmine » dans le groupe « _postgres », afin que l’application Redmine puisse accéder à sa base de données par l’intermédiaire de la socket Unix configurée par défaut.

On passe maintenant à la seule phase de compilation de ce guide. Pour mémoire, je vous rappelle que vous aurez besoin de Xcode 4.3.2 et ses outils de compilation en ligne de commande. La compilation de Ruby nécessite en effet l’utilisation des « autotools GNU ». Ces outils étaient fournis avec Xcode, mais Apple a décidé de ne plus les livrer à partir de Xcode 4.3. Nous allons donc les installer dans la l’arborescence « /usr/local »:

redhub:~ admin$ curl -O http://mirrors.kernel.org/gnu/autoconf/autoconf-latest.tar.gz
redhub:~ admin$ tar zxf autoconf-latest.tar.gz
redhub:~ admin$ cd autoconf-2.68/
redhub:autoconf-2.68 admin$ ./configure --prefix=/usr/local
redhub:autoconf-2.68 admin$ make
redhub:autoconf-2.68 admin$ sudo make install
redhub:autoconf-2.68 admin$ cd ..
redhub:~ admin$ rm -rf autoconf-2.68/
redhub:~ admin$ curl -O http://mirrors.kernel.org/gnu/automake/automake-1.11.4.tar.gz
redhub:~ admin$ tar zxf automake-1.11.4.tar.gz
redhub:~ admin$ cd automake-1.11.4
redhub:automake-1.11.4 admin$ ./configure --prefix=/usr/local
redhub:automake-1.11.4 admin$ make
redhub:automake-1.11.4 admin$ sudo make install
redhub:automake-1.11.4 admin$ cd ..
redhub:~ admin$ rm -rf automake-1.11.4
redhub:~ admin$ curl -O http://mirrors.kernel.org/gnu/libtool/libtool-2.4.2.tar.gz
redhub:~ admin$ tar zxf libtool-2.4.2.tar.gz
redhub:~ admin$ cd libtool-2.4.2
redhub:libtool-2.4.2 admin$ ./configure --prefix=/usr/local
redhub:libtool-2.4.2 admin$ make
redhub:libtool-2.4.2 admin$ sudo make install
redhub:libtool-2.4.2 admin$ cd ..
redhub:~ admin$ rm -rf libtool-2.4.2

Dernière étape de préparation, la création de la base de données Redmine sous postgreSQL. On vérifie tout d’abord si postgreSQL est en cour d’exécution:

redhub:~ admin$ sudo serveradmin status postgres
postgres:state = "RUNNING"

Si ce n’est pas le cas, on démarre le service:

redhub:~ admin$ sudo serveradmin start postgres

Puis on crée la base de données, ainsi qu’un utilisateur (Role) « redmine » pour postgreSQL. Dans le code SQL ci-dessous, n’oubliez pas de remplacer <password> par un mot de passe non trivial…

redhub:~ admin$ sudo psql -U _postgres -d postgres
psql (9.0.5)
Type "help" for help.
 
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD '<password>' NOINHERIT VALID UNTIL 'infinity';
CREATE ROLE
postgres=# CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine TEMPLATE template0;
CREATE DATABASE
postgres=# \q

On va maintenant passer à l’installation de Rvm, Redmine, Unicorn. Ces opérations s’effectuent avec le compte de l’utilisateur « redmine », puisque nous allons créer un environnement Ruby spécifique pour cet utilisateur.

redhub:~ admin$ sudo su - redmine

On commence ensuite par créer un environnement minimal pour l’utilisateur. Cet environnement sera modifié automatiquement par Rvm lors de son installation.

redhub:~ redmine$ touch .bash_profile
redhub:~ redmine$ echo insecure > .curlrc
redhub:~ redmine$ cat > .gemrc
install: --no-rdoc --no-ri
update: --no-rdoc --no-ri
^D

On installe rvm:

redhub:~ redmine$ curl -L get.rvm.io | bash -s stable
redhub:~ redmine$ source ~/.bash_profile

A noter que la deuxième ligne recharge l’environnement bash, car l’installation de rvm la modifie (rvm est en fait une fonction bash qui doit être chargée dans le shell). C’est tout pour l’installation de rvm. Rien de bien compliqué pour l’instant.

Passons à la création de notre environnement Ruby. Nous allons installer Ruby 1.9.3. Il est en effet impossible d’installer une version plus ancienne de Ruby à l’aide de rvm, à cause d’une incompatibilité avec Xcode 4. La conséquence de cette limitation, c’est que nous devrons ensuite installer la version 1.4 lorsque celle-ci sera disponible, car la version 1.3 n’est pas compatible avec Ruby 1.9. On installe également la version 0.8.7 de rake:

redhub:~ redmine$ rvm install 1.9.3
redhub:~ redmine$ rvm use 1.9.3 --default
redhub:~ redmine$ gem install rake --version=0.8.7

On passe ensuite à l’installation de la version de développement de Redmine, en clonant directement le dépôt Subversion:

redhub:~ redmine$ svn co http://redmine.rubyforge.org/svn/branches/branches/1.4-stable redmine
redhub:~ redmine$ cd redmine

La version de développement de Redmine utilise dorénavant « bundle » pour gérer ses dépendances. On utilise donc la commande « bundle » pour installer (toujours dans notre environnement protégé) l’ensemble des gems nécessaires au fonctionnement de redmine en production (donc les gems nécessaires pour le développement et les tests unitaires), en excluant mysql, puisque nous utilisons postgreSQL, et rmagick, car nous ne disposons pas des librairies natives nécessaires (j’aurais pu décrire leur installation, mais comme rmagick est facultatif, je laisse cette tache aux bons soins du lecteur qui en aurait besoin).

redhub:redmine redmine$ bundle install --without development test rmagick mysql

C’est terminé en ce qui concerne l’installation de Redmine. On a donc maintenant un environnement Ruby on Rails totalement dédié à notre applicatif, qui n’interfère en rien avec les autres applicatifs du système. Passons à la configuration de Redmine (rien de compliqué, c’est une configuration classique)

redhub:redmine redmine$ echo "production:
  adapter: postgresql
  database: redmine
  username: redmine
  password: <password>
  encoding: utf8
  schema_search_path: public" > config/database.yml
redhub:redmine redmine$ RAILS_ENV=production rake config/initializers/session_store.rb
redhub:redmine redmine$ rake generate_session_store
redhub:redmine redmine$ RAILS_ENV=production rake db:migrate
redhub:redmine redmine$ RAILS_ENV=production rake redmine:load_default_data

Dernière étape avec l’utilisateur « redmine »: L’installation et la configuration d’Unicorn. Unicorn est disponible sous forme de gem, et sa configuration consiste en l’écriture d’un script Ruby.:

redhub:redmine redmine$ echo 'gem "unicorn", "4.2.1"' > Gemfile.local
redhub:redmine redmine$ bundle install
redhub:redmine redmine$ mkdir -P shared/logs
redhub:redmine redmine$ mkdir shared/pids

Créez ensuite un fichier nommé « unicorn.rb » dans le répertoire courant et copiez le script suivant:

mem = `sysctl -n hw.memsize`
gb = mem.to_i / (1024 * 1024 * 1024)
 
# Up to 4GB = one process per GB of RAM, then 2/GB for each above 4, up to the max
num_proc = (gb < 5 ? gb : (2 * gb - 4))
num_proc = 1 if num_proc < 1 
num_proc = 10 if num_proc > 10
 
worker_processes num_proc
working_directory = "/usr/local/share/redmine/redmine"
 
listen "127.0.0.1:6660" 
timeout 600
 
preload_app true
 
pid "#{working_directory}/shared/pids/unicorn.pid"
 
stderr_path "#{working_directory}/shared/logs/unicorn.stderr.log"
stdout_path "#{working_directory}/shared/logs/unicorn.stdout.log"
 
if GC.respond_to?(:copy_on_write_friendly=)
  GC.copy_on_write_friendly = true
end
 
before_fork do |server, worker|
  old_pid = "#{working_directory}/shared/pids/unicorn.pid.oldbin"
  if File.exists?(old_pid) && server.pid != old_pid
    begin
      Process.kill("QUIT", File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
      # someone else did our job for us
    end
  end
  # the following is recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.connection.disconnect!
  end
end
 
after_fork do |server, worker|
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.establish_connection
  end
end

Je vous invite vivement à consulter la documentation d’Unicorn pour plus d’informations. Sachez simplement que le script va déterminer le nombre d’instances de l’application à lancer (en fonction de l’espace mémoire disponible sur le serveur), et ouvrir une socket TCP, sur le port 6660, accessible uniquement en local (cette socket sera la « cible » du proxy Apache que nous verrons plus tard).

C’est maintenant terminé pour l’ensemble des taches à effectuer avec le compte « redmine ». Retournez sur votre compte administrateur. C’est en effet avec ce compte que devront etre effectuées les 2 taches restantes, c’est à dire l’écriture de la plist launchd qui va lancer notre serveur unicorn + redmine, puis l’écriture et l’activation de la webapp Apache.

Pour ce guide, et afin d’obtenir un fonctionnement consistant avec les autres services web d’Apple (gestionnaire de profils, wiki), j’ai choisi de ne pas utiliser de VirtualHost Apache pour Redmine: L’application sera disponible sur le site par défaut du serveur, à travers (pour moi, le nom de machine sera certainement différent pour vous) l’URL https://redhub.local/redmine. Cette solution permet également de pouvoir profiter de SSL sans tous les problèmes de virtual hosting…

On commence par la plist launchd. Prenez votre éditeur favori, et créez le fichier « /Library/LaunchDaemons/com.zoccolo.redmine.plist ». Copiez la plist ci-dessous dans le fichier, puis sauvez:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>GroupName</key>
	<string>redmine</string>
	<key>UserName</key>
	<string>redmine</string>
	<key>Label</key>
	<string>com.zoccolo.redmine</string>
	<key>KeepAlive</key>
	<true/>
	<key>WorkingDirectory</key>
	<string>/usr/local/share/redmine/redmine</string>
	<key>EnvironmentVariables</key>
    	<dict>
      		<key>GEM_HOME</key>
		<string>/usr/local/share/redmine/.rvm/gems/ruby-1.9.3-p194</string>
      		<key>GEM_PATH</key>
		<string>/usr/local/share/redmine/.rvm/gems/ruby-1.9.3-p194:/usr/local/share/redmine/.rvm/gems/ruby-1.9.3-p194@global</string>
      		<key>PATH</key>
		<string>/usr/local/share/redmine/.rvm/gems/ruby-1.9.3-p194/bin:/usr/local/share/redmine/.rvm/gems/ruby-1.9.3-p194@global/bin:/usr/local/share/redmine/.rvm/rubies/ruby-1.9.3-p194/bin:/usr/local/share/redmine/.rvm/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
   	</dict>
	<key>ProgramArguments</key>
	<array>
		<string>unicorn_rails</string>
		<string>-E</string>
		<string>production</string>
		<string>-c</string>
		<string>./unicorn.rb</string>
		<string>--path</string>
		<string>/redmine</string>
	</array>
</dict>
</plist>

Changez le propriétaire du fichier, puis démarrez Unicorn:

redhub:~ admin$ sudo chown root:wheel /Library/LaunchDaemons/com.zoccolo.redmine.plist 
redhub:~ admin$ sudo launchctl load -w /Library/LaunchDaemons/com.zoccolo.redmine.plist

Il reste à écrire l’application web pour Apache. Apple utilise une plist pour décrire la configuration de ses webapps (man webapp.plist). Nous allons faire de meme. Prenez de nouveau votre éditeur favori, et créez le fichier « /etc/apache2/webapps/com.zoccolo.webapp.redmine.plist ». Copiez la plist ci-dessous dans le fichier, puis sauvez:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
	<dict>
		<key>name</key>
		<string>com.zoccolo.webapp.redmine</string>
		<key>includeFiles</key>
		<array>
			<string>/etc/apache2/httpd_redmine.conf</string>
		</array>
 
		<key>launchKeys</key>
		<array>
      			<string>com.zoccolo.redmine</string>
      			<string>org.postgresql.postgres</string>
		</array>
		<key>requiredModuleNames</key>
		<array>
			<string>proxy_module</string>
			<string>xsendfile_module</string>
		</array>
	</dict>
</plist>

Faites la meme chose avec le fichier « /etc/apache2/httpd_redmine.conf »:

Alias /redmine "/usr/local/share/redmine/redmine/public"
 
# This is needed to workaround a mod_proxy bug <https://issues.apache.org/bugzilla/show_bug.cgi?id=37770>
SetEnvIf Request_URI "^/redmine/.*" force-proxy-request-1.0=1
SetEnvIf Request_URI "^/redmine/.*" proxy-nokeepalive=1
 
<Proxy balancer://redmineserver>
    BalancerMember http://127.0.0.1:6660
</Proxy>
 
RewriteEngine on
 
# Redirect all non-static requests to unicorn
RewriteCond %{REQUEST_FILENAME} ^/redmine/(.*)$
RewriteCond /usr/local/share/redmine/redmine/public/%1 !-f
RewriteRule ^/redmine/.*$ balancer://redmineserver%{REQUEST_URI} [P,QSA,L]
 
<Directory /usr/local/share/redmine/redmine/public>
    Options FollowSymLinks MultiViews
 
    Order allow,deny
    Allow from all
</Directory>

Dernière étape, l’activation de notre nouvelle webapp, et le redémarrage d’Apache.

redhub:~ admin$ sudo webappctl start com.zoccolo.webapp.redmine
redhub:~ admin$ sudo apachectl graceful

Et voila, si tout s’est bien passé, vous devez avoir accès à votre redmine directement depuis un navigateur.

Dans le prochain (et dernier) article, je passerai un peu de temps à installer quelques plugins bien utiles pour Redmine et lui refaire son look avec un thème un peu plus évolué que le thème par défaut. Je terminerai par l’intégration entre Redmine et Gitolite, ce qui permettra la gestion des dépôts git directement depuis Redmine.

Ces questions trouvent leur réponse dans un outil de gestion de version et de tracking. Github en est un parfait exemple. Mais Github est une solution publique, et externaliser le stockage de vos milliers de lignes de code top secrètes ne vous plait pas… Dans cet article, je vais vous indiquer pas à pas comment héberger son propre « clone » de Github sur MacOSX Lion Serveur.

A ce titre je vous propose d’utiliser Redmine, Gitolite, ainsi que le plugin Redmine-gitolite qui va permettre une intégration parfaite entre ces 2 outils. Il existe déjà de nombreux articles similaires, proposant l’installation de ces outils sur Linux/Unix et Windows, mais l’installation sur OSX Serveur est plus périlleuse, car elle nécessite la mise à jour de plusieurs composants ruby utilisés par Apple, mise à jour rendant certaines fonctionnalités systèmes inopérantes.

Pré requis

Pour suivre ce guide, vous aurez besoin de:

1. MacOS X Lion Server à jour (10.7.3 au moment où j’écris ces lignes).
2. Xcode 4.3.2 et ses outils en ligne de commande (malheureusement nécessaires car git n’est pas installé dans le système de base).
3. Un compte administrateur.
4. Être à l’aise avec le Terminal. La plupart des manipulations vont en effet nécessiter l’exécution de commandes dans un shell.

Gitolite: Un serveur Git sécurisé

L’application Gitolite permet l’hébergement centralisé de dépôts Git. Elle propose une gestion très fine des droits d’accès aux dépôts, ainsi qu’un accès sécurisé à travers SSH et un couple de clés publiques/privées. Redmine gérant la notion de projet public/privé, je décrirai également la configuration de git-daemon, qui permettra un accès anonyme en lecture seule aux dépôts qui autorisent un tel accès.

Comme expliqué plus haut, Gitolite est accessible à travers SSH. Par conséquent, la première chose à faire est d’activer le serveur SSH de votre serveur si ce n’est déjà fait. Pour cela, lancez l’application Server.app et autorisez les sessions à distance via SSH:

Nous allons ensuite créer l’utilisateur « git » local sur le serveur. Cet utilisateur sera le propriétaire local des dépôts hébergés, ainsi que le compte SSH utilisé pour y accéder. C’est parti pour nos premières lignes de shell.

Première étape, créer un groupe « git » et un utilisateur « git »:

redhub:~ admin$ sudo dseditgroup -q -o create git
redhub:~ admin$ MAXID=$(dscl . -list /Users UniqueID | awk '{print $2}' | sort -ug | tail -1)
redhub:~ admin$ USERID=$((MAXID+1))
redhub:~ admin$ sudo dscl -q . -create /Users/git UniqueID $USERID
redhub:~ admin$ sudo dscl -q . -create /Users/git RealName "Gitolite Server Account"
redhub:~ admin$ sudo dscl -q . -create /Users/git PrimaryGroupID $(dscl -q . -read /Groups/git PrimaryGroupID | awk '{print $2}')

On désactive l’authentification par mot de passe, puisque seule l’authentification par paire clé publique/privée sera utilisée:

redhub:~ admin$ sudo dscl -q . -create /Users/git Password \*

On configure le répertoire racine du compte ainsi que son shell. Vous pouvez changer l’emplacement du home directory, mais personnellement j’ai l’habitude de mettre tout ce qui concerne les données « serveur » dans /Library/Server…

redhub:~ admin$ sudo dscl -q . -create /Users/git NFSHomeDirectory /Library/Server/Gitolite
redhub:~ admin$ sudo dscl -q . -create /Users/git UserShell /bin/bash

Enfin, on supprime les données du compte non nécessaires. Cela a pour effet, entre autre, de ne pas faire apparaitre le compte dans les liste des utilisateurs du panneau de configuration, ainsi que dans l’écran de login du serveur.

redhub:~ admin$ sudo dscl -q . -delete /Users/git AuthenticationAuthority
redhub:~ admin$ sudo dscl -q . -delete /Users/git PasswordPolicyOptions
redhub:~ admin$ sudo dscl -q . -delete /Users/git dsAttrTypeNative:KerberosKeys
redhub:~ admin$ sudo dscl -q . -delete /Users/git dsAttrTypeNative:ShadowHashData

Enfin, on crée le dossier de l’utilisateur « git » et on lui en attribue la propriété.

redhub:~ admin$ sudo mkdir /Library/Server/Gitolite
redhub:~ admin$ sudo chown git:git /Library/Server/Gitolite

Passons maintenant à l’installation de Gitolite. Vous allez avoir besoin d’une clé SSH pour vous identifier en tant qu’administrateur du serveur Gitolite. Donc si vous n’en possédez pas déjà une, il est temps de la créer.

redhub:~ admin$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/admin/.ssh/id_rsa):
Created directory '/Users/admin/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/admin/.ssh/id_rsa.
Your public key has been saved in /Users/admin/.ssh/id_rsa.pub.
The key fingerprint is:
22:09:39:ff:a2:43:84:c4:9f:3b:c4:79:b1:4f:48:42 admin@redhub.local
The key's randomart image is:
+--[ RSA 2048]----+
|. .E |
| o o o |
|..* = + |
|. .X = . |
| .. * + S |
| .o o o |
| . o . |
| .. . |
| .. |
+-----------------+

Copier votre clé publique (dans mon cas /Users/admin/.ssh/id_rsa.pub) dans un endroit où vous pourrez y accéder depuis le compte utilisateur « git », en la renommant, car Gitolite utilise le nom de fichier de la clé publique en tant qu’identifiant (login) de l’utilisateur (pour la gestion des droits d’accès aux dépôts git).

redhub:~ admin$ cp .ssh/id_rsa.pub /tmp/admin.pub

Il est temps de télécharger et installer Gitolite. Récemment, son auteur l’a réécrit entièrement et indique que cette nouvelle version (« g3″) est la seule supportée à présent. C’est donc cette version que nous allons cloner depuis son dépôt github La version disponible actuellement ne fonctionnant pas correctement sur MacOS X (pour une raison obscure), j’ai « forké » de dépôt initial et modifié le code dans mon dépôt pour contourner le problème. C’est donc ma version que nous allons cloner, et procéder à l’installation Edit: L’auteur a pris en compte mes remarques et modifications afin de faire fonctionner gitolite sur MacOS X. Par conséquent mon fork n’a plus de raison d’être et c’est le dépôt original que nous allons cloner. L’opération de téléchargement et d’installation sont effectuées avec l’utilisateur local « git ».

redhub:~ admin$ sudo su - git
redhub:~ git$ clone git://github.com/sitaramc/gitolite.git
redhub:~ git$ mkdir bin 
redhub:~ git$ gitolite/install -ln
# ^D = Presser Control+D ci-dessous
redhub:~ git$ cat >.bash_profile
export PATH=$HOME/bin:$PATH
^D
redhub:~ git$ source .bash_profile
redhub:~ git$ gitolite setup -pk /tmp/admin.pub
Initialized empty Git repository in /Library/Server/Gitolite/repositories/gitolite-admin.git/
Initialized empty Git repository in /Library/Server/Gitolite/repositories/testing.git/
WARNING: /Library/Server/Gitolite/.ssh missing; creating a new one
WARNING: /Library/Server/Gitolite/.ssh/authorized_keys missing; creating a new one

Gitolite est maintenant fonctionnel, et pour toute information complémentaire, je vous invite à consulter sa documentation (ce qui n’est pas nécessaire si vous allez jusqu’au bout de ce guide, puisque Redmine gèrera entièrement Gitolite à votre place).

Il reste la cerise sur le gâteau: L’accès restreint en lecture seule, configurable pour chaque projet, à l’aide de git-daemon. Si vous ne voulez pas proposer un tel accès, inutile de suivre les étapes suivantes, passez directement à l’installation de Redmine.

Première étape, modifier l’umask de gitolite afin que git-daemon (qui fonctionnera avec les droits restreints de l’utilisateur « gitdaemon » que nous allons créer juste après) puisse accéder aux dépôts. Pour cela (toujours avec le compte « git »), éditez le fichier .gitolite.rc et remplacez la valeur de la variable UMASK, par défaut à 0077, par 0027.

Les opérations à réaliser avec le compte « git » sont maintenant terminées. Quittez le compte (et retournez à votre compte administrateur) en pressant Controle+D.

Seconde étape: On crée un utilisateur « gitdaemon », avec comme groupe primaire le groupe « git ».

redhub:~ admin$ MAXID=$(dscl . -list /Users UniqueID | awk '{print $2}' | sort -ug | tail -1)
redhub:~ admin$ USERID=$((MAXID+1))
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon UniqueID $USERID
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon RealName "Git Daemon Server Account"
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon PrimaryGroupID $(dscl -q . -read /Groups/git PrimaryGroupID | awk '{print $2}')
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon Password \*
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon NFSHomeDirectory /var/empty
redhub:~ admin$ sudo dscl -q . -create /Users/gitdaemon UserShell /usr/bin/false
redhub:~ admin$ sudo dscl -q . -delete /Users/gitdaemon AuthenticationAuthority
redhub:~ admin$ sudo dscl -q . -delete /Users/gitdaemon PasswordPolicyOptions
redhub:~ admin$ sudo dscl -q . -delete /Users/gitdaemon dsAttrTypeNative:KerberosKeys
redhub:~ admin$ sudo dscl -q . -delete /Users/gitdaemon dsAttrTypeNative:ShadowHashData

Prenez ensuite votre éditeur favori, et copiez la plist ci-dessous dans le fichier /Library/LaunchDaemons/com.zoccolo.git-daemon.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>GroupName</key>
    <string>git</string>
    <key>KeepAlive</key>
    <true/>
    <key>Label</key>
    <string>com.zoccolo.git-daemon</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/git</string>
        <string>daemon</string>
        <string>--base-path=/Library/Server/Gitolite/repositories</string>
        <string>--reuseaddr</string>
        <string>--syslog</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>UserName</key>
    <string>gitdaemon</string>
</dict>
</plist>

Enfin, changez le propriétaire du fichier (qui doit obligatoirement être root) et son group (qui doit obligatoirement être wheel), et lancez git-daemon à l’aide de la commande « launchctl load » (à noter l’option -w qui permet de spécifier que le daemon doit être relancé après un redémarrage du serveur):

redhub:~ admin$ sudo chown root:wheel /Library/LaunchDaemons/com.zoccolo.git-daemon.plist
redhub:~ admin$ sudo launchctl load -w /Library/LaunchDaemons/com.zoccolo.git-daemon.plist

« Et voila !! »

Le couple Gitolite + git-daemon est en place sur votre serveur !

Passons maintenant au plat de résistance: Redmine. Mais ce sera pour un prochain article !

La solution: TRIM Enabler

groths.org » TRIM Enabler for Mac.

Understanding iOS 4 Backgrounding and Delegate Messaging @ Cocoanetics.

Après lecture de cette série d’article, l’envoi de messages en Objective-C n’aura plus de secret pour vous !

C’est par là (en Anglais évidemment) : bbum’s weblog-o-mat » Blog Archive » objc_msgSend() Tour Part 1: The Road Map.

Apple ne pouvant prendre le risque de se retrouver également dans la tourmente, ZFS est tout simplement abandonné.

Source : StorageMojo.

Plusieurs informations contradictoires circulent sur les raisons de cette absence. Robin Harris, sur son blog, évoque quelques pistes intéressantes, et tente de prédire le futur de ZFS (Article en Anglais) : Why did Apple drop ZFS?.

• Snow Leopard, 29 €
• Snow Leopard, 5 licences, 49 €
• Mac Box Set (Snow Leopard, iLife 09, iWork 09), 169 €

« Apple a annoncé aujourd’hui que la commercialisation de Mac OS X 10.6 Snow Leopard débuterait le vendredi 28 août auprès des Revendeurs Agréés Apple », précise le communiqué de presse de Cupertino.

« les ingénieurs d’Apple ont perfectionné 90 % des plus de 1 000 projets de Mac OS X. Les utilisateurs remarqueront ainsi un Finder plus réactif ; Mail qui charge les messages deux fois plus rapidement ; Time Machine dont la sauvegarde initiale est accélérée jusqu’à 80 % ; un Dock avec intégration d’Exposé ; QuickTime X avec un lecteur remanié qui permet aux utilisateurs de visualiser, d’enregistrer, d’ajuster et de partager facilement leurs vidéos ; et une version 64 bits de Safari 4 qui offre jusqu’à 50 % de gain de performances et résiste aux plantages causés par les plug-ins. Snow Leopard voit sa taille réduite de moitié par rapport à la version précédente et libère ainsi jusqu’à 7 Go d’espace disque une fois installé.

Pour la première fois, les applications système, notamment le Finder, Mail, iCal, iChat et Safari, sont en 64 bits et Snow Leopard, grâce à sa prise en charge des processeurs 64 bits, met à profit les gros volumes de RAM pour offrir des performances accrues et une sécurité renforcée, tout en restant compatible avec les applications 32 bits. Grand Central Dispatch (GCD) procure aux développeurs de logiciels un nouveau moyen révolutionnaire de créer des applications tirant parti des processeurs multicœurs. Quant à OpenCL, standard ouvert basé sur le langage C, il permet aux développeurs d’exploiter l’incroyable puissance de calcul du processeur graphique pour des tâches d’une toute autre nature.

Snow Leopard est le seul système d’exploitation pour ordinateurs de bureau à intégrer la prise en charge de Microsoft Exchange Server 2007, permettant d’utiliser Mac OS X Mail, le Carnet d’adresses et iCal pour envoyer et recevoir des e-mails, lancer des invitations à des réunions ou y répondre, ainsi que faire des recherches dans vos contacts et gérer ces derniers avec des listes d’adresses globales. Les informations issues d’Exchange fonctionnent de façon totalement transparente dans Snow Leopard, de sorte que les utilisateurs peuvent tirer parti des fonctionnalités exclusives de Mac OS X telles que les recherches Spotlight et les aperçus Coup d’œil. »