===== Redmine =====
==== pré-requis ====
  * ruby (1.9.3)
  * rails
  * une connexion internet acceptant le https
  * git
  * un utilisateur redmine sans les droits sudo

==== Installation de Redmine ====

=== Téléchargement ===

Nous utiliserons git mais il peut aussi être récupéré via svn à l'adresse http://svn.redmine.org/redmine

<code bash>
cd /opt
git clone https://github.com/redmine/redmine
</code>

=== Installation ===

== Installation et utilisation de MySql ==

Comme toujours, gem va avoir besoin de composants présents dans des librairies annexes

<code bash>
sudo apt-get install libmysql-ruby libmysqlclient-dev mysql-client
rvmsudo gem install mysql2
</code>

Ensuite il faut créer un utilisateur redmine et une base de même nom sur phpmyadmin.
Et enfin il faut donner tous les renseignement necessaires à redmine, ceci ce trouve dans /opt/databse.yml

<code>
production:
  adapter: mysql2
  database: redmine
  host: sql.minet.net
  username: redmine
  password: passwd
</code>

== Bundler pour les autres plugins ==

On va avoir besoin de bundler pour récupérer toutes les gems dont redmine a besoin.

<code bash>
gem install bundler
</code>

Un Gemfile est donné avec les sources de redmine lors du git, il faut donc executer bundler dans le dossier d'installation de redmine, ici /opt/redmine.
rmagick a besoin de dépendances supplémentaires pour fonctionner.

<code bash>
sudo apt-get install libmagickwand-dev
rvmsudo bundle install --without development test
</code>

== Generation des Token ==

<code bash>
rake generate_secret_token
</code>

Si la commande renvoie une erreur dans /opt/redmine essayer :

<code bash>
rvmsudo rake generate_secret_token
</code>

== On peuple la base sql ==

On crée la structure de la base :

<code bash>
RAILS_ENV=production rake db:migrate
</code>

Puis on la peuple (il demande aussi la langue a ce niveau là) :

<code bash>
RAILS_ENV=production rake redmine:load_default_data
</code>

== Dossiers nécessaires à redmine ==

<code bash>
mkdir -p tmp tmp/pdf public/plugin_assets
sudo chown -R redmine:redmine files log tmp public/plugin_assets
sudo chmod -R 755 files log tmp public/plugin_assets
</code>

== Test (non nécessaire) ==

Ceci ne fonctionne qu'en local :

<code bash>
rvmsudo ruby script/rails server webrick -e production
</code>

**Ceci est uniquement pour tester si l'installation est complète !**

==== Déploiement sur apache2 -> très mauvaise idée ! ====

==== Déploiment sur nginx ====

=== Utilisation d'unicorn ===

== Installation ==

Comme d'hab avec ruby on utilise gem. On se place dans /opt/redmine et on édite le Gemfile fourni pour que le versionning corresponde. On ajoute :
<code>
gem "unicorn"
</code>

Puis on installe :

<code bash>
rvmsudo gem install unicorn
</code>

== Configuration ==

On crée un fichier unicorn.rb dans /opt/redmine/ avec le contenu suivant :

<code ruby>
$unicorn_user = "redmine"
$unicorn_group = "redmine"

worker_processes 2
working_directory '/opt/redmine'

listen      "127.0.0.1:3000"
timeout     30

pid         "tmp/pids/unicorn.pid"
stderr_path "log/unicorn.log"
stdout_path "log/unicorn.log"

preload_app  true

before_fork do |server, worker|
  defined?(ActiveRecord::Base) and ActiveRecord::Base.connection.disconnect!
end

after_fork do |server, worker|
  defined?(ActiveRecord::Base) and ActiveRecord::Base.establish_connection

  begin
    uid, gid = Process.euid, Process.egid
    user, group = $unicorn_user, $unicorn_group
    target_uid = Etc.getpwnam(user).uid
    target_gid = Etc.getgrnam(group).gid
    worker.tmp.chown(target_uid, target_gid)
    if uid != target_uid or gid != target_gid
      Process.initgroups(user, target_gid)
      Process::GID.change_privilege(target_gid)
      Process::UID.change_privilege(target_uid)
    end
  rescue
    if RAILS_ENV = "development"
      STDERR.puts "could not change user, oh well"
    else
      raise e
    end
  end
end
</code>

Enfin on crée le script de démarrage dans /etc/init.d/redmine avec le contenu suivant :

<code bash>
#!/bin/bash
#
# unicorn_rails_redmine Startup script for unicorn.
#
# chkconfig: - 85 15
# description: redmine on unicorn stabin:/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/gems/ruby-1.9.3-p448/bin:/usr/local/rvm/rt/stop script.
#

#
# set rvm environment valiables.
#
export PATH=/usr/local/rvm/gems/ruby-1.9.3-p448@redmine/bin:/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/gems/ruby-1.9.3-p448/bin:/usr/local/rvm/rubies$
export GEM_HOME=/usr/local/rvm/gems/ruby-1.9.3-p448@redmine
export GEM_PATH=/usr/local/rvm/gems/ruby-1.9.3-p448@redmine:/usr/local/rvm/gems/ruby-1.9.3-p448@global:/usr/local/rvm/gems/ruby-1.9.3-p448
export BUNDLE_PATH=
export MY_RUBY_HOME=/usr/local/rvm/rubies/ruby-1.9.3-p448
export IRBRC=/usr/local/rvm/rubies/ruby-1.9.3-p448/.irbrc


set -u
set -e

APP_NAME=redmine
APP_ROOT="/opt/$APP_NAME"
CNF="$APP_ROOT/unicorn.rb"
PID="$APP_ROOT/tmp/pids/unicorn.pid"
ENV=production

UNICORN_OPTS="-D -E $ENV -c $CNF"

old_pid="$PID.oldbin"bin:/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/gems/ruby-1.9.3-p448/bin:/usr/local/rvm/

cd $APP_ROOT || exit 1
sig () {bin:/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/gems/ruby-1.9.3-p448/bin:/usr/local/rvm/
        test -s "$PID" && kill -$1 `cat $PID`
}

oldsig () {
        test -s $old_pid && kill -$1 `cat $old_pid`
}

case ${1-help} in
start)
        sig 0 && echo >&2 "Already running" && exit 0
        cd $APP_ROOT ; unicorn_rails $UNICORN_OPTS
        ;;
stop)
        sig QUIT && exit 0
        echo >&2 "Not running"
        ;;
force-stop)
        sig TERM && exit 0
        echo >&2 "Not running"
        ;;
restart|reload)
        sig HUP && echo reloaded OK && exit 0
        echo >&2 "Couldn't reload, starting instead"
        unicorn_rails $UNICORN_OPTS
        ;;
upgrade)
        sig USR2 && exit 0
        echo >&2 "Couldn't upgrade, starting instead"
        unicorn_rails $UNICORN_OPTS
        ;;
rotate)
        sig USR1 && echo rotated logs OK && exit 0
        echo >&2 "Couldn't rotate logs" && exit 1
        ;;
*)
        echo >&2 "Usage: $0 <start|stop|restart|upgrade|rotate|force-stop>"
        exit 1
        ;;
esac
</code>

On le rend exécutable et on le teste :
<code bash>
sudo chmod +x /etc/init.d/redmine
sudo service redmine start
</code>

Puis il faut l'activer au démarrage de la VM :

<code bash>
sudo update-rc.d redmine defaults 
</code>

=== On passe a Nginx ===

== Installation ==

<code bash>
sudo apt-get install nginx
</code>

== Configuration ==

On va venir éditer /etc/nginx/sites-available/redmine

<code>
pstream redmine {
        server 127.0.0.1:3000;
}

server {
        server_name redmine.minet.net;
        root /opt/redmine/public;

        proxy_redirect off;

        location / {
                try_files $uri/index.html $uri.html $uri @ruby;
        }

        location @ruby {
                proxy_set_header  X-Real-IP  $remote_addr;
                proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header  Host $http_host;
                proxy_redirect off;
                proxy_pass http://redmine;
        }
}
</code>

Puis on enable redmine sur le serveur :

<code>
sudo ln -s /etc/nginx/sites-available /etc/nginx/sites-enable
</code>

Enfin, on redémarre nginx !

<code>
sudo /etc/init.d/nginx restart
</code>


==== Et les mails ? (parce que le spam c'est bon :D) ====

Les mails ont besoin d'un gem qui ne s'installe pas forcément automatiquement :

<code bash>
gem install mail
</code>

Puis on renseigne le fichier /opt/redmine/config/configuration.yml

<code>
default:
  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      address: smtp.minet.net
      port: 25
</code>

==== MAJ ====

Arrêter le service :
<code bash>
service redmine stop
</code>

  - Telecharger la nouvelle version et la copier dans le dossier /opt/redmineXXX
  - Copier le contenu de /opt/redmine vers /opt/redmine.oldXXX
  - Supprimer entièrement le contenu de /opt/redmine/ avant d'y copier les fichiers de la nouvelle version
  - Copier depuis la version précédente les fichiers unicorn.rb, config/database.yml, config/configuration.yml, public/themes/MiNET
  - Se placer dans le dossier /opt/redmine puis exécuter : rvmsudo bundle install
  - Exécuter : rake generate_secret_token
  - Puis : rake config/initializers/session_store.rb
  - Enfin : chown -R redmine:redmine ./

=== Test ===

Il faut ensuite relancer le service :

<code bash>
service redmine start
</code>

Si tout démarre, il suffit d'aller vérifier dans la configuration de redmine sur le site que tout est ok et que la version est bien la plus à jour et dans ce cas c'est gagné !

== Sinon... ==

En cas d'erreur de démarrage unicorn, il faut aller voir les logs :

<code path>
/opt/redmine/log/
</code>