Redmine in Tomcat installieren

Redmine im Tomcat installieren

Redmine ist ein Werkzeug zur Projektverwaltung - in erster Linie für Software-Entwicklungs-Projekte geeignet.

Redmine ist in Ruby mit dem Framework Ruby on Rails programmiert. Es steht unter der General Public License v2 (GPL).

Hier soll es als Beispiel dienen, wie man auf der Hostsharing-Infrastruktur mit der Tomcat-Option Rails-Anwendungen betrieben kann.

Vorbereitungen

Ich brauche:

1. die aktuelle Redmine Version von redmine.org (zur Zeit Version 2.5.1)
2. die aktuelle JRuby Version von jruby.org (aktuell Version 1.7.11)

Download und Entpacken

 cd
 mkdir tmp
 cd tmp
 wget http://jruby.org.s3.amazonaws.com/downloads/1.7.11/jruby-bin-1.7.11.tar.gz
 wget http://www.redmine.org/releases/redmine-2.5.1.tar.gz
 tar xzf jruby-bin-1.7.11.tar.gz
 tar xzf redmine-2.5.1.tar.gz  

Datenbank anlegen und konfigurieren

Die Datenbank wird mit HSAdmin angelegt.

Auf der Kommandozeile könnte das so aussehen:

 hsscript -u xyz00 -i
 Password: ********
 xyz00@hsadmin> mysqluser.add({set:{name:'xyz00_dbadmin',password:'geheim'}})
 xyz00@hsadmin> mysqldb.add({set:{name:'xyz00_redmine',user:'xyz00_dbadmin'}})
 xyz00@hsadmin> bye

Dann wird die Datenbank in Redmine konfiguriert, indem die "Datei config/database.yml" in der entpackten Redmine-Software angelegt. Inhalt der Datei:

 production:
   adapter: mysql
   database: xyz00_redmine
   host: localhost
   username: xyz00_dbadmin
   password: "geheim"
   encoding: utf8

Bauen der Anwendung

 export PATH=$HOME/tmp/jruby-1.7.11/bin:$PATH

Zur Kontrolle (sollte das gem im bin-Verzeichnis der JRuby-Installation liefern):

 which gem

Webapplikation bauen

Als normaler User baue ich dann die Web-Applikation zusammen:

Download und entpacken von redmine in /home/user/redmine-n.n.n

 tar xzf redmine-1.1.1.tar.gz
 cd /home/user/redmine-1.1.1

Installation einiger Ruby-Gem-Pakete:

 mkdir /home/user/.gem
 export GEM_HOME=/home/user/.gem
 gem install -v=0.4.2 i18n
 gem install -v=1.0.1 rack
 gem install jruby-openssl
 gem install activerecord-jdbcpostgresql-adapter
 gem install rake

In config/environment.rb habe ich folgende Zeilen eingefügt:

Unmittelbar vor Rails::Initializer.run do |config|

   if RUBY_PLATFORM =~ /java/
      require 'rubygems'
      gem 'activerecord-jdbc-adapter'
      require 'arjdbc'
   end

Direkt hinter Rails::Initializer.run do |config| dann:

   config.action_controller.session = { :key => "_myapp_session", :secret => "ueber-30-zeichen-session-key" }

Dann lege ich die Datei config/database.yml mit folgendem Inhalt an:

   production:
     adapter: jdbc
     driver: org.postgresql.Driver
     url: jdbc:postgresql://localhost/redmine
     encoding: unicode
     username: redmine
     password: mein_geheimnis
     host: localhost
     port: 5432

Jetzt kann ich die Datenbank initialisieren:

   export RAILS_ENV=production
   jruby ~/.gem/bin/rake db:migrate
   jruby ~/.gem/bin/rake redmine:load_default_data

Ein erster Test mit:

   jruby ./script/server -e production

Jetzt sollte Redmine im internen WEBrick-Webserver unter http://localhost:3000 erreichbar sein. Die Anmeldung mit admin/admin kann man schon ausprobieren...

Die letzten Schritte zum Bau der WAR-Datei:

   gem install warbler
   ~/.gem/bin/warble config

Folgendes in der Datei config/warble.rb hinter Warbler::Config.new do |config| anpassen bzw. ergänzen:

   config.dirs = %w(app config lib log vendor tmp extra files lang)
   config.gems += ["activerecord-jdbcpostgresql-adapter", "i18n", "jruby-openssl", "rack"]
   config.gems["i18n"] = "0.4.2"
   config.gems["rack"] = "1.0.1" 

Der letzte Schritt

   ~/.gem/bin/warble

erzeugt eine Datei redmine-1.1.1.war, die ich in redmine.war umbenenne und im Tomcat deploye.

Installation bei Hostsharing

Voraussetzung: Installierter Tomcat-Webserver

Bei Hostsharing lege ich einen Postgres-Datenbank-Admin und eine Datenbank mit HSAdmin an.

In die Datenbank spiele ich über http://phppgadmin.hostsharing.net einen Dump meiner lokalen Datenbank ein.

Die redmine.war-Datei kopiere ich auf den Hostsharing-Server. Im webapps-Verzeichnis, das für meine gewünschte Domain konfiguriert ist, lege ich ein Verzeichnis redmine an. In dieses Verzeichnis entpacke ich die redmine.war mit dem jar-Befehl. Zuletzt passe ich noch die Datenbank-Zugangsparameter in der Datei WEB-INF/config/database.yml aus dem ausgepackten Archiv an.

Mit einem Neustart des Tomcat (oder der Redmine-Applikation im Tomcat) kann Redmine dann genutzt werden.