Project

General

Profile

HowTo Install Redmine 12x with Mercurial and Subversion on Ubuntu Server 1004 » History » Revision 55

Revision 54 (Dimitry Profus, 2011-09-22 12:32) → Revision 55/56 (Dimitry Profus, 2011-09-22 21:04)

h1. HowTo Install Redmine 1.2.x with Mercurial and Subversion on Ubuntu Server 10.04 

 {{toc}} 

 h2. Redmine Installation 

 # Install the LAMP stack 
 <pre> 
 $ sudo tasksel install lamp-server 
 </pre> 
 # Install the required packages 
 <pre> 
 $ sudo apt-get install build-essential subversion llibmysqlclient15-dev libdigest-sha1-perl libgemplugin-ruby libgemplugin-ruby1.8 libruby-extras libruby1.8-extras rails rake ruby rubygems rubygems1.8 ruby1.8-dev libopenssl-ruby1.8  
 </pre> 
 # Install the required Ruby gems 
 <pre> 
 $ sudo gem install rails -v=2.3.11 --no-ri --no-rdoc 
 $ sudo gem install rake -v=0.8.7 --no-ri --no-rdoc 
 $ sudo gem uninstall rake -v=0.9.2  
 $ sudo gem install i18n -v=0.4.2 --no-ri --no-rdoc 
 $ sudo gem install mysql --no-ri --no-rdoc 
 </pre>  
 # Download Redmine into /user/share/redmine directory 
 <pre> 
 $ sudo svn co http://redmine.rubyforge.org/svn/branches/1.2-stable /usr/share/redmine 
 </pre> 
 # Create an empty MySQL database and accompanying user named redmine for example. 
 <pre> 
 $ mysql -u root -p 
 (enter the mysql root user password) 
 > create database redmine character set utf8; 
 > create user 'redmine'@'localhost' identified by '[password]'; 
 > grant all privileges on redmine.* to 'redmine'@'localhost' identified by '[password]'; 
 > exit 
 </pre> 
 # Copy config/database.yml.example to config/database.yml and edit this file in order to configure your database settings for "production" environment. 
 <pre> 
 $ sudo cp /usr/share/redmine/config/database.yml.example /usr/share/redmine/config/database.yml 

 $ sudo nano /usr/share/redmine/config/database.yml 

 Modify to the following and save (ctrl+x) 

 production: 
   adapter: mysql 
   socket: /var/run/mysqld/mysqld.sock 
   database: redmine 
   host: localhost 
   username: redmine 
   password: [password] 
   encoding: utf8 
 </pre> 
 # Generate a session store secret. 
 <pre> 
 $ cd /usr/share/redmine 

 $ sudo rake generate_session_store 
 </pre> 
 # Create the database structure, by running the following command under the application root directory: 
 <pre> 
 $ cd /usr/share/redmine 

 $ sudo rake db:migrate RAILS_ENV="production"  
 </pre> 
 # Insert default configuration data in database, by running the following command: 
 <pre> 
 $ sudo RAILS_ENV=production rake redmine:load_default_data 
 </pre> 
 # Setting up permissions 
 <pre> 
 $ cd /usr/share/redmine 
 $ sudo chown -R www-data:www-data files log tmp public/plugin_assets 
 $ sudo chmod -R 755 files log tmp public/plugin_assets 
 </pre> 
 # Test using the webrick web server 
 <pre> 
 $ cd /usr/share/redmine 

 $ ruby script/server webrick -e production 

 Point your web browser at http://[my server ip]:3000 

 You should now see the application welcome page. 
 </pre> 


 h2. Apache Integration 

 # Install the required packages 
 <pre> 
 $ sudo apt-get install libapache2-mod-passenger 
 </pre> 
 # Add a symbolic link to the public redmine web directory 
 <pre> 
 $ sudo ln -s /usr/share/redmine/public /var/www/redmine 
 </pre> 
 # Configure Passanger to run as www-data 
 <pre> 
 $ sudo nano /etc/apache2/mods-available/passenger.conf 

 Add the follow line and save (ctrl+x) 

 PassengerDefaultUser www-data 
 </pre> 
 # Create a new Apache site file 
 <pre>  
 $ sudo nano /etc/apache2/sites-available/redmine  
 </pre> 
 Add the following lines and save (ctrl+x) 
 <pre> 
 <VirtualHost *:80> 
         ServerAdmin webmaster@localhost 
         DocumentRoot /var/www 
         ServerName myservername 
        
         RewriteEngine on 
         RewriteRule     ^/$    /redmine    [R] 

         <Directory /var/www/redmine> 
                 RailsBaseURI /redmine 
                 PassengerResolveSymlinksInDocumentRoot on 
         </Directory> 

         ErrorLog /var/log/apache2/error.log 

         # Possible values include: debug, info, notice, warn, error, crit, 
         # alert, emerg. 
         LogLevel warn 

         CustomLog /var/log/apache2/access.log combined 
 </VirtualHost> 
 </pre> 
 For SSL add the following text instead 
 <pre> 
 <VirtualHost *:443> 
         ServerAdmin webmaster@localhost 
         DocumentRoot /var/www 
         ServerName myservername 

         SSLEngine On 
         SSLCertificateFile /etc/apache2/ssl/redmine.pem 

         RewriteEngine on 
         RewriteRule     ^/$    /redmine    [R] 

         <Directory /var/www/redmine> 
                 RailsBaseURI /redmine 
                 PassengerResolveSymlinksInDocumentRoot on 
         </Directory> 

         ErrorLog /var/log/apache2/error.log 

         # Possible values include: debug, info, notice, warn, error, crit, 
         # alert, emerg. 
         LogLevel warn 

         CustomLog /var/log/apache2/access.log combined 
 </VirtualHost> 
 </pre> 
 # Enable the Redmine website 
 <pre> 
 $ sudo a2dissite default 
 $ sudo a2ensite redmine 
 </pre>  
 # Enable the Passenger and Rewite modules and restart Apache 
 <pre> 
 $ sudo a2enmod passenger 
 $ sudo a2enmod rewrite 
 $ sudo /etc/init.d/apache2 restart 
 </pre>  
 # Test the setup 
 <pre> 
 Open up your favorite web browser and goto 

 http://[my site or ip]/redmine 
 </pre> 

 h2. Mercurial Integration 

 # Install the latest Mercurial release  
 <pre> 
 $ sudo apt-get install python-software-properties 
 $ sudo add-apt-repository ppa:mercurial-ppa/releases 
 $ sudo apt-get update 
 $ sudo apt-get install mercurial libapache-dbi-perl libapache2-mod-perl2 
 </pre> 
 # Create the hg web directory 
 <pre> 
 $ sudo mkdir -p /var/hg/repos 
 </pre> 
 # Create the web cgi script file 
 <pre> 
 $ sudo nano /var/hg/hgwebdir.cgi 

 Add the following and save 

 #!/usr/bin/env python 
 # 
 from mercurial import demandimport; demandimport.enable() 
 from mercurial.hgweb.hgwebdir_mod import hgwebdir 
 import mercurial.hgweb.wsgicgi as wsgicgi 
 application = hgwebdir('hgweb.config') 
 wsgicgi.launch(application) 
 </pre> 
 # Create the cgi web config file  
 <pre> 
 $ sudo nano /var/hg/hgweb.config 

 Add the following and save 

 [paths] 
 /=/var/hg/repos/** 

 [web] 
 allow_push = * 
 push_ssl = false 
 allowbz2 = yes 
 allowgz = yes 
 allowzip = yes 
 </pre> 
 # Setup permissions 
 <pre> 
 $ sudo chown -R www-data:www-data /var/hg 
 $ sudo chmod gu+x /var/hg/hgwebdir.cgi 
 </pre> 
 # Create a Apache config file 
 <pre> 
 $ sudo nano /etc/apache2/conf.d/hg.config 

 Add the following and save 
 
 PerlLoadModule Apache::Redmine 
 ScriptAlias /hg    "/var/hg/hgwebdir.cgi" 
 <Location /hg    > 
	 AuthType Basic 
	 AuthName "Redmine Mercurial Repository"  
	 Require valid-user 

	 #Redmine auth 
	 PerlAccessHandler Apache::Authn::Redmine::access_handler 
	 PerlAuthenHandler Apache::Authn::Redmine::authen_handler 
	 RedmineDSN "DBI:mysql:database=redmine;host=localhost"  
	 RedmineDbUser "redmine"  
	 RedmineDbPass "password"  
 </Location> 
 </pre> 
 # Add a symbolic link to Redmine.pm 
 <pre> 
 $ sudo ln -s /usr/share/redmine/extra/svn/Redmine.pm /usr/lib/perl5/Apache/Redmine.pm 
 $ sudo ln -s /usr/share/redmine/extra/svn/Redmine.pm /usr/lib/perl5/Apache2/Redmine.pm   
 </pre> 
 # Enable the required Apache modules and restart Apache 
 <pre> 
 $ sudo /etc/init.d/apache2 restart 
 </pre> 
 # Create a new test repository and project in Redmine 
 <pre> 
 $ sudo hg init /var/hg/repos/test 
 $ sudo chown -R www-data:www-data /var/hg/repos/test 

 Create a new project with and identifier 'test' 

 In the project Settings > Repository set 
 SCM: Mercurial 
 Path to repository: /var/hg/repos/test 
 Press the 'Create' button 

 Goto to the Repository tab of the test project 
 </pre> 
 # View the test repository in the web browser  
 <pre> 
 > http://[my site name]/hg/test 
 </pre> 

 h2. Subversion Integration 

 # Install the latest Mercurial release  
 <pre> 
 $ sudo apt-get install subversion libapache2-svn libapache-dbi-perl libapache2-mod-perl2 
 </pre> 
 # Create the svn repository directory 
 <pre> 
 $ sudo mkdir /var/svn 
 </pre> 
 # Setup permissions 
 <pre> 
 $ sudo chown -R www-data:www-data /var/svn 
 </pre> 
 # Add a symbolic link to Redmine.pm 
 <pre> 
 $ sudo ln -s /usr/share/redmine/extra/svn/Redmine.pm /usr/lib/perl5/Apache/Redmine.pm 
 $ sudo ln -s /usr/share/redmine/extra/svn/Redmine.pm /usr/lib/perl5/Apache2/Redmine.pm   
 </pre> 
 # Create a Apache config file 
 <pre> 
 $ sudo nano /etc/apache2/conf.d/svn.config 
 </pre> 
 Add the following and save 
 <pre> 
 PerlLoadModule Apache::Redmine 
 <Location /svn> 
	 DAV svn 
	 SVNParentPath "/var/svn"  
	 Order deny,allow 
	 Deny from all 
	 Satisfy any 

	 PerlAccessHandler Apache::Authn::Redmine::access_handler 
	 PerlAuthenHandler Apache::Authn::Redmine::authen_handler 
	 AuthType Basic 
	 AuthName "Redmine Subversion Repository"  

	 #read-only access     
	 <Limit GET PROPFIND OPTIONS REPORT> 
		 Require valid-user 
		 Allow from [my server ip] 
		 # Allow from another-ip 
		  Satisfy any 
	 </Limit> 
		 # write access 
		 <LimitExcept GET PROPFIND OPTIONS REPORT> 
		 Require valid-user 
	 </LimitExcept> 

	 ## for mysql 
	 RedmineDSN "DBI:mysql:database=redmine;host=localhost"  
	 RedmineDbUser "redmine"  
	 RedmineDbPass "password"  
 </Location> 
 </pre> 
 # Enable the required Apache modules and restart Apache 
 <pre> 
 $ sudo a2enmod dav_svn 
 $ sudo /etc/init.d/apache2 restart 
 </pre> 
 # Create a new test repository 
 <pre> 
 $ sudo svnadmin create /var/svn/test 
 $ sudo chown -R www-data:www-data /var/svn/test 
 </pre> 

 h2. Automate Repository Creation 

 # Enable WS for repository management and generate and API key 
 <pre> 
 * From the Redmine Administration menu select Settings 
 * Click on the Repositories tab 
 * Enable the 'Enable WS for repository management' checkbox 
 * Click the 'Generate a key' link  
 * Press the 'Save' button 
 </pre> 
 # Modify reposman.rb 
 <pre> 
 $ sudo nano /usr/share/extra/svn/reposman.rb 

 Add the following to module SCM and save   

   module Mercurial 
     def self.create(path) 
       Dir.mkdir path 
       Dir.chdir(path) do 
         system_or_raise "hg init" 
       end 
     end 
   end 
 </pre> 
 # Schedule the reposman.rb script to run every minute 
 <pre> 
 $ sudo nano /etc/cron.d/redmine 
 </pre> 
 Add one of the following lines (not both) and save. 
 (Note: you will need to replace [my API key]    with the API key you generated in step 1)  
 . 
 To create subversion repositories add: 
 <pre> 
 * * * * * root ruby /usr/share/redmine/extra/svn/reposman.rb --redmine localhost/redmine --scm Subversion --svn-dir /var/hg/repos --owner www-data --url file:///var/svn --key=[my API key] >> /var/log/reposman.log 
 </pre> 
 OR to create Mecurial repositories add: 
 <pre> 
 * * * * * root ruby /usr/share/redmine/extra/svn/reposman.rb --redmine localhost/redmine --scm Mercurial --svn-dir /var/hg/repos --owner www-data --url /var/hg/repos --key=[my API key] >> /var/log/reposman.log 
 </pre> 

 h2. Automatic refresh of repositories in Redmine 

 # Schedule the fetch_changesets script to run every 15 minutes 
 <pre> 
 $ sudo nano /var/cron.d/redmine 

 Add the following line and save 

 */15 * * * * root ruby /usr/share/redmine/script/runner "Repository.fetch_changesets" -e production > /dev/null 2>&1 
 </pre> 
 # Setup a changegroup script on the Mercurial server to run fetch_changesets after each push to a Mercurial repository  
 <pre> 
 $ sudo nano /var/hg/changegroup-hook 
 </pre> 
 Add the following text and save 
 (Note: you will need to replace [your API key] the API key you generated in Redmine 
 <pre> 
 #!/bin/sh 
 curl "http://localhost/redmine/sys/fetch_changesets?key=[your API key]"    > /dev/null 2>&1 
 </pre> 
 Setup permissions 
 <pre> 
 $ sudo chown www-data:www-data /var/hg/changegroup-hook 
 $ sudo chmod ug+x /var/hg/changegroup-hook 
 </pre> 
 Modify the hgweb.config file 
 <pre> 
 $ sudo nano /var/hg/hgweb.config 
 </pre> 
 Add the following section and save 
 <pre> 
 [hooks] 
 changegroup = /var/hg/changegroup-hook 
 </pre> 

 h2. Email Integration 

 # Install and configure Sendmail 
 <pre> 
 $ sudo apt-get install sendmail 
 $ sudo sendmailconfig 

 (Answer Yes to all questions which you will be asked) 
 </pre> 
 # Update the Redmine configuration file 
 <pre> 
 $ sudo nano /usr/share/redmine/config/configuration.yml 

 Add the following text and save 

  production: 
    email_delivery: 
      delivery_method: :sendmail 
 </pre> 

 h2. Backup to Amazon S3 cloud storage 

 # Create an account at http://aws.amazon.com/  
 # Create a S3 bucket using the aws management console https://console.aws.amazon.com/ec2/home 
 # View your Access Keys at https://aws-portal.amazon.com/gp/aws/developer/account/index.html?action=access-key 
 # Build and install fuse to 2.8.4 
 <pre> 
 $ sudo wget https://launchpad.net/ubuntu/+archive/primary/+files/fuse_2.8.4.orig.tar.gz 
 $ cd fuse-2.8.4/ 
 $ tar xzf fuse_2.8.4.orig.tar.gz  
 $ sudo ./configure  
 $ sudo make 
 $ sudo make install 
 </pre> 
 # Build and install s3fs 1.61  
 <pre> 
 $ sudo apt-get install libxml2-dev 
 $ wget http://s3fs.googlecode.com/files/s3fs-1.61.tar.gz 
 $ tar xzf s3fs-1.61.tar.gz  
 $ cd s3fs-1.61/ 
 $ sudo ./configure  
 $ sudo make 
 $ sudo make install 
 </pre> 
 # Create a s3fs password file 
 <pre> 
 $ sudo nano /etc/passwd-s3fs 
 </pre> 
 Added your 'Access Key ID' and 'Secret Access Key' separated by a colon 
 <pre> 
 [accessKeyId]:[secretAccessKey] 
 </pre> 
 Setup permissions 
 <pre> 
 sudo chmod 650 /etc/passwd-s3fs 
 </pre>  
 # Create mounting point 
 <pre> 
 $ sudo mkdir /mnt/s3 
 </pre> 
 # Mount your S3 bucket 
 <pre> 
 $ sudo s3fs [your-s3-bucket-name] /mnt/s3 -ouse_cache=/tmp -o allow_other 
 </pre> 
 # Test it worked and unmount 
 <pre> 
 $ echo hello > /mnt/s3/welcome.txt 
 $ ls /mnt/s3 
 $ sudo umount /mnt/s3 
 </pre> 
 # Create upstart job to mount the s3 file system start up 
 <pre> 
 $ sudo nano /etc/init/s3.conf 
 </pre> 
 Add the following text and save. 
 <pre> 
 description "Mount Amazon S3 file system on system start" 

 start on (local-filesystems and net-device-up IFACE!=lo) 
 stop on runlevel [016] 

 respawn 

 exec s3fs -f [your-s3-bucket-name] /mnt/s3 -ouse_cache=/tmp -o allow_other 
 </pre> 
 # Start the s3 job 
 <pre> 
 sudo start s3 
 </pre> 
 # Test it worked 
 <pre> 
 $ echo hello > /mnt/s3/welcome2.txt 
 $ ls /mnt/s3 
 </pre> 
 # Create the backup script file 
 <pre> 
 $ sudo apt-get install mailutils 
 $ sudo nano /usr/local/bin/backup-redmine.sh 
 </pre> 
 Add the following text and save. 
 <pre> 
 #!/bin/bash 
 # Script to backup Redmine files to a mounted storage device 
 # with daily, weekly, monthly backup rotation 

 # Admin email address 
 admin_email="admin@yourdomain.com"  

 # What to backup 
 db_dump_file="/usr/share/redmine/db/redmine-database-dump.sql"  

 backup_files="$db_dump_file /usr/share/redmine/files /var/hg /var/svn"  
 backup_files="$backup_files /etc/apache2/conf.d/hg.conf /etc/apache2/sites-available/redmine" 
 backup_files="$backup_files /etc/init/s3.conf /etc/cron.d/redmine /usr/local/bin/backup-redmine.sh" 

 # Where to backup to 
 backup_dir="/mnt/s3"  

 # Set database access 
 redmine_db_name="redmine"  
 redmine_db_user="redmine"  
 redmine_db_password="password"  

 # Encryption 
 encrypt="false"  
 secret_passphrase="your_gpg_passphrase"  

 # Set rotation in units of days 
 daily_remove_older_than=6 
 weekly_remove_older_than=30 
 monthly_remove_older_than=62 

 # Redirect stderr to a log file 
 error_log="/tmp/backup-redmine.log"  
 exec 6>&2 
 exec 2>$error_log 

 on_exit() { 
     # Restore IO output 
     exec 2>&6    6>$- 

     # Check for errors 
     if [ -s "$error_log" ]; then 
         logger -t "$0"    -s "#### Backup Failed ####"  
         logger -t "$0" -s -f "$error_log"  
         cat "$error_log" | mail -s "Backup failed!"    $admin_email 
      else 
         logger -t "$0" -s "Backup Complete"  
     fi 

     # Clean up 
     rm -f $error_log 
 } 

 trap on_exit EXIT SIGHUP SIGINT SIGQUIT SIGTERM 

 # Setup variables for the archive filename. 
 hostname=$(hostname -s) 
 date_time_stamp=`date +%Y-%m-%d_%Hh%Mm`          # Datestamp e.g 2011-12-31_23h59m 
 date_stamp=`date +%Y-%m-%d`                      # Date p e.g 2011-12-31 
 date_day_of_week=`date +%A`                      # Day of the week e.g. Monday 
 date_day_of_month=`date +%e`                     # Date of the Month e.g. 27 

 # Is the    backup directory mounted? 
 mount | grep -sq "$backup_dir" 
 if    [ $? != 0 -eq 1 ]; then 
    echo "backup destination ${backup_dir} is not mounted" >&2 
    
   exit 1 
 fi 

 # Make required directories 
 [ -d "$backup_dir/monthly" ] || mkdir "$backup_dir/monthly"  
 [ -d "$backup_dir/weekly" ] || mkdir "$backup_dir/weekly"  
 [ -d "$backup_dir/daily" ] || mkdir "$backup_dir/daily"  

 # Delete old archives 
 find "${backup_dir}/monthly" -mtime +"$monthly_remove_older_than" -type f -name "${hostname}_*" -exec rm {} \; 
 find "${backup_dir}/weekly" -mtime +"$weekly_remove_older_than" -type f -name "${hostname}_*" -exec rm {} \; 
 find "${backup_dir}/daily" -mtime +"$daily_remove_older_than" -type f -name "${hostname}_*" -exec rm {} \; 

 archive_file="${backup_dir}/daily/${hostname}_${date_time_stamp}.tgz"  

 [ $encrypt == "true" ] && archive_file="${archive_file}.gpg"  

 # Dump the redmine database 
 rm -f "$db_dump_file" 
 mysqldump --user="${redmine_db_name}" --password="${redmine_db_password}" "${redmine_db_name}" > $db_dump_file 

 # Write the archive file to the backup directory 
 if [ $? == 0 ]; then 
     if [ $encrypt == "true" ]; then 
     
         tar czP $backup_files | gpg -c -z 0 --yes --no-use-agent --passphrase="${secret_passphrase}" -o "${archive_file}"  
  
     else 
     
         tar czfP "${archive_file}" $backup_files 
     fi 
 fi 

 # Make a weekly backup on Saturday 
 if [ $date_day_of_week == "Saturday" ]; then 
     weekly_count=$(find "${backup_dir}/weekly" -type f -name "${hostname}_${date_stamp}*" | wc -l) 
     [ $weekly_count == "0" ] && cp "${archive_file}" "${backup_dir}/weekly/"  
 fi 

 # Make a monthly backup on the first day of every    month 
 if [ $date_day_of_month == "1" ]; then 
     monthly_count=$(find "${backup_dir}/monthly" -type f -name "${hostname}_${date_stamp}*" | wc -l) 
     [ $monthly_count == "0" ] && cp "${archive_file}" "${backup_dir}/monthly/"  
 fi 

 if [ -s "$error_log" ]; then 
     exit 1 
 else 
     exit 0 
 fi 
 </pre> 
 # Setup permissions  
 <pre> 
 sudo chmod ug+x /usr/local/bin/backup-redmine.sh 
 sudo chmod o-r /usr/local/bin/backup-redmine.sh 
 </pre> 
 # Schedule the backup to run once a day at 12am 
 <pre> 
 $ sudo nano /etc/cron.d/redmine 

 Add the following line and save 

 0 0 * * * root /usr/local/bin/backup-redmine.sh 
 </pre> 
 # Test the script 
 <pre> 
 $ sudo backup-redmine.sh 
 $ ls -R /mnt/s3 
 </pre>