Problem

When i upgraded Prestashop 1.5 to 1.6.0.11 the product and category SEF / Friendly URLs do not work but the CMS pages do.

Cause

In my case i believe it was because i had custom Friendly URLs set so this solution might for everyone, in which case use the Useful Links.

Solution

1. Go to your prestashop admin / Preferences / SEO & URLs page
2. Navigate to the Schema of URLs section
3. Click on Save. 
4. Disable Friendly URLs, click save in this section, then re-enable the Friendly URLs
5. Test, You might get away with the steps so far.
6. As a further step, copy the Schema of URLs from a fresh install of prestashop (same version) and then click save.
7. Disable Friendly URLs, click save in this section, then re-enable the Friendly URLs
8. Test

Other Things to Try

There are several tutorials out there that tell you to experiment by turning the apache multiviews on/off and the same with mod_security. After you change either of these you need to disable the freiendly urls and then re-enable them, this causes the .htaccess to be regenerated correctely. These methods will only help a few people and you really should not disable mod_security.

Useful Links

• [SOLVED] If friendly urls enabled then product images do not show - OUT - 1.6.0.11 [7 Jan 2015] - PrestaShop
• PrestaShop 1.5/1.6 SEO and URLs Preference Options Tutorial
• apache - SEF URLs i PS 1.6 returns 404 - Stack Overflow
• Friendly URL not working - Ecommerce x PrestaShop - PrestaShop

Problem

When i upgraded Prestashop 1.5 to 1.6.0.11 there were no carriers available even though they were setup correctely in PS 1.5

Cause

This is caused by prestashop changing how they handled the shipping matrix. The matrices that are present after upgrade reflect he carriers that you had there before but the costing data and ranges have not be preserved.

Solution

Go into the shipping methods and repopulated the costing data into the ranges and add ranges as needed as if you were setting these up from fresh

This is what I did to get mantis to work with SourceSVN

• Create folder D:\Documents\Developer\

Install Subversion

• Install CollabNet Subversion Edge D:\Documents\Developer\SubversionEdge\
• Create a Normal User and assign it to the ‘Test’ repositories - shoulders

Install Xampp

• Install xampp - D:\Documents\Developer\xampp\
• Change xampp ports (optional)
  
  To prevent issues with my other webservers I use for development. It is easier to reconfigure the one sever that is not going to get changed.
  
  
  • Apache
    • Httpd.conf
      • Listen 80 –> 81
      • ServerName localhost:80 -> :81
  • Httpd-ssl.conf
    • Listen 443 –> 444
    • <VirtualHost _default_:443> -> <VirtualHost _default_:444>
• Mysql –my.ini
  • [client] port = 3306 – 3307
  • [mysqld] port=3306 - 3307
• Php.ini - if you do not change this you get a #2002 – connection actively reused error
  • mysql.default_port=3306 – 3307
  • mysqli.default_port=3306 - 3307

Install Mantis

• create a table in PHPMyadmin called mantis using utf8_general_ci collation
• set a username and password ; mantis : YFb5fNTtmXsFHpBP, grant all privileges on the mantis SQL table
• setup mantis, install with MySQLi – it is quicker of connecting
  • Nb you need a MySQL root account to install. This might change in a newer version. Stupid, I had to use root and not password
  • Default username/password: administrator / root
  • Renamed default user to mantis-admin
  • Delete the admin folder ( I renamed it just in case)
• Run mantis
• Create a normal user – if more than one user - shoulders
• Install Source Integration Plugin and SourceSVN
• Config settings I changed
  • Bug Fixed Message Template – I added everything in ?
  • API Key – added my random generated key here
  • SVN: Path to binary - D:\Documents\Developer\SubversionEdge\bin also “D:\Documents\Developer\SubversionEdge\bin” might be valid when there are spaces in the path
  • SVN: Trust All SSL Certs – ticked, allows me to use a self-signed cert whilst being secure
  • SVN: Use Windows `start` - I believe you need this when using windows. ?

Create Repository

• Goto mantis/repositories
• Type in ‘test’ for name and select SVN for type
• Click create repository
• Fill in the following details, leave the rest
  • Name – prefilled - Test
  • URL – this is the front facing url for the repository
    https://svn.exampleserver.com:18080/svn/
  • SVN Username – don’t use the super admin, you might consider a repository specific username here
  • SVN Password
  • Standard Repository – tick
  • Click ‘update repository’
  • Click ‘import everything’

This is far as I got, more errors and bugs. Mantis is free but needs a serious GUI upgrade

My notes on using and configuring Redmine.

Notes

• General
  • you can have multiple repositories per project
  • Redmine Tutorial - YouTube - A tutorial on using Redmine software project management suite.
• Security
  • rename admin and set a decent password (ie redmine-admin) or shoulders. You cannot unmkae this account as an administrator
  • make redmine to use https/SSL (this is not easy)
  • create a new user, ie yourusername, you can then makes this user an administrator by clicking a box.
  • it is better to keep the main admin and your username seperate. at some point in the future other people might start using redmine. als, it makes it easier to get back in if you forget your password.
  • when setting these 2 users, hide your email address.
• Show smaller images in the editor
  • How to resize an image in redmine so it will show up, properly resized, when a pdf is produced from the issue? - Stack Overflow
  • Feature #38504: Display pasted images in appropriate size on HiDPI displays - Redmine
    • I want to update the patch to specify the width of an image in the markup like GitHub, instead of using the "@2x" trick. This approach allows users to change or remove the width value if necessary.

      Textile:
      !{width: 400px;}.clipboard-202402030959-abcde.png!
      
      CommonMark Markdown:
      <img src="/clipboard-202402030959-abcde.png" width="400">
      
      Deprecated Redcarpet-based Markdown:
      ![](clipboard-202402030959-abcde.png)
      (size specifications are not supported)

Configure Redmine Emails

• if emails is not setup you get the following message:
  

  Email delivery is not configured, and notifications are disabled.
  Configure your SMTP server in config/configuration.yml and restart the application to enable them.

configure redmine@quantumwarp.com as the system email

Create the email account

• create email account on your cPanel with 0mb mailbox and forwarding if required. this advoids another mail address to monitor.

configure email in configuration.xml, you must restart redmine to see the changes.

• http://www.redmine.org/projects/redmine/wiki/EmailConfiguration
• NB you will struggle to get it to work until you know the following editing the configuration file.
• when you edit the appropriate section you will notice 'email_delivery:' this is also at the top og the configuration file above all of the email configuratioins and obviously declaring this twice causes problemd so just rem this out at the top of the you email configuration section. it makes it neater doing it there than at the top of the file.

now go back to the emails settings in redmine app as they will be available.

• change the 'Emission email address' to redmine@quantumwarp.com
• send a test email, the button is at the bottom left.
• redmine@quantumwarp.com can be used for incoming stuff.
• under the 'General Tab' change 'Host name and path' to 'svn.quantumwarp.com:81/redmine'

Errors and Alerts

when you first run Redmine you are presented with the following message. You should load the default configuratioin.

Security and SSL

If you are using this on a real website you might want to use SSL and make your installation secure. There are a few things you can do. For most people running on their local machine that do not want it on the internet do not require any of these settings, but it will not harm if they did. Following the instructions above you should already be using ProxyRequests Off

<Directory> / <Location>

• location acts upon the url only, directory works on the physical file path, so they basically do the same thing via the 2 declarative paths.
• however, directory is a little more secure because there can be multip-le urls poitning to the same file whereas when using directory there is only 1 file path so directory is better for security permissions etc ..
• directory and location directives can be used within a virtual host and will apply to that virtualhost only, if not it will be applied to the main/default website/name/localhost etc..
• using <directory> is better than <location>

SSL on non default port

• SSL on Webrick
• Defect #12102: Installed Redmine in a sub-URI: Links are generated not correctly - Redmine - This is where i got the proper subdirectory code that works and also has the code for SSL usage
• Listen Directive - Official Documentation
• How to configure WEBrick to serve Redmine over SSL using openSSL certificate | PI Media - Web Apps Development

The optional protocol argument is not required for most configurations. If not specified, https is the default for port 443 and http the default for all other ports. The protocol is used to determine which module should handle a request, and to apply protocol specific optimizations with the AcceptFilter directive.

You only need to set the protocol if you are running on non-standard ports. For example, running an https site on port 8443:

Listen 192.170.2.1:8443 https

Hooks

• Secure the commit path ie /sys/ folder - i read some where that you should protect the {redmine}/sys folder and was not sure why or where i have seen that. but the reaon is to protect where you send the post-commit.bat submissions ie. curl "http://<redmine url>/sys/fetch_changesets?key=<your service key>"
• use https cURL and https for submitting locations
• HowTo Automate repository creation - Redmine - Mentions Web Service and security

Secure Proxy

• ProxyRequests Off - prevent abuse of proxy
• Protect the subversion / REdmine installation with IP blocking in Apache
• HowTo Install Redmine on subdirectory (sub-URI) on Apache - Redmine - Tells of how you should restrict access when using apache proxy

apache httpd.conf

<Proxy *>
  Order Deny,Allow
  Deny from all
  Allow from 192.168.0
</Proxy>

• http://serverfault.com/questions/500650/how-can-i-enable-mod-proxy-http
• Hide the Apache Web Server Version number with ServerSignature and ServerTokens directives
• How to hide apache information with ServerSignature and ServerTokens directives - Virendra's TechTalk

Some Notes Before We Start

When you have a webserver running you probably would like redmine through that server aswell to keep things easier, reducing port forwarding requirements and the number of addresses you hand out. You could just hand out the new address which usually looks like http://localhost:3000/ if you want, but why not do a proper integration.

These methods will allow you to run redmine from your normal webserver or localhost, http://localhost/ with no port number on the end (this assumes that your webserver does not have a port number, using port 80).

Tthere are 2 parts of this process to consider:

1. Changing the folder from which redmine is server ie from http://localhost:3000/ to http://localhost:3000/redmine/
2. Proxying / Redirecting redmine from the server where it is (ie http://localhost:3000/) to youer apache server http://localhost/

With the following instructions i will assume the following

• Redmine is located at http://localhost:3000/
• The target apache server http://localhost/redmine/ - might need to amend this rule
  NB if you are just running your apache at http://localhost/ you can just use the following instead http://localhost/redmine/

If you just want the code, click here, this will take you to the bottom where you can just get the code for a quick start without any of the history.

Files

This section is not required reading but might help if you have issues or question later on.

During my research i cam across references to Redmine files where you could put code. I am going to list them here and what i think they do.

• {redmine}/config.ru - this is the intialization configuration file, i think
• {redmine}/config/enviroment.rb - This file controls additonal settings that will get applied to both development and production enviroments
• {redmine}/config/additional_enviroment.rb - This is only present in later version of Ruby/Rails/Redmine and probably needs creating. . This file controls additonal settings that will get applied to both development and production enviroments similiar enviroment.rb does. Not all commands in this file work in this file that would in enviroment.rb .
• {redmine}/config/application.rb - dont bother altering code in this
• {redmine}/config/development.rb - this files allows you to add additional commands/instructions to just the development enviroment
• {redmine}/config/production.rb - this files allows you to add additional commands/instructions to just the production enviroment

Move Redmine to a Sub-Folder

Method 1 - Using WebBrick

This techniques is the best an i have taken most of the information from Defect #12102: Installed Redmine in a sub-URI: Links are generated not correctly - Redmine

This method also utilises the inbuilt WebBrick Webserver, This is an excellent simple solution but if you are going to use this for a lot of users you should perhaps think about using Thin Server, this will require slightly different instructions and some more work. WebBrick is classed as a reference server and if you are going to server more than 20 people at a time there will be large performance issues. For the most of us WebBrick will be fine.

config.ru

# This file is used by Rack-based servers to start the application.

require ::File.expand_path('../config/environment',  __FILE__)
map '/redmine' do
  run RedmineApp::Application
end

Replace the contents of {redmine}/config.ru with this code. This also assumes you have not already made any alterations to this file.

This code does 2 things

1. changes all links in the pages to /redmine/
2. changes the actual served root. Files in the /public/ directory are now served as http://3000/redmine/ instead of http://localhost:3000/

The root folder effectively no longer exists, you get page not found supplied by the webserver if you browse to http://localhost:3000/ and this is normal.

Other Static Asset Commands

You can also change the dynamic urls by using the 2 following commands:

• RedmineApp::Application.routes.default_scope = { :path => '/redmine', :shallow_path => '/redmine'
• RedmineApp::Application.routes.default_scope = '/redmine'

which cause the following issues:

• the directory of the dynamic links changes but the root of the webserver stays the same. This means that the static files stay in the root directory (http://localhost/) while all of the dynamic links are in http://localhost:3000/redmine/
• it is very difficult to proxy these 2 folders because this will involve complex rewrite rules

enviroment.rb

ActionController::Base.relative_url_root = '/redmine'

Add this to the end of {redmine}config/enviroment.rb. I also think you can put this in either development.rb or production.rb, this change will then only occur in that particular enviroment.

This code alters the path of the links pointing to the static files such as javascripts and CSS. Currently all paths for these still point to the root http://localhost:3000/ but they actual ar now present at http://localhost:3000/redmine/ and even though we have added the code in config.ru these paths are not altered so we need this code to correct that.

NB:

• RedmineApp::Application.routes.default_scope = '/redmine' works but is not the prefered method. This must also be put before RedmineApp::Application.initialize!
• ActionController::AbstractRequest.relative_url_root = "/redmine" - Does not work, it was for older versions of Redmine
• config.action_controller.relative_url_root = '/redmine' - not sure about this

You now have moved your Redmine installation to a subfolder

Method 2 - Thin Server + Passenger Server

this will be for my Thin server notes when i do them, there is also the Passenger Webserver to consider. Each has there own method. Basically youo can run these servers with switches to perform the directory change, You can then proxy this over to your main webserver as in the instructions below. Check my General Links section for resources.

Proxying Redmine to Apache / Xampp

Redmine in Root Folder

This is the easiest of the methods to implement. You can simply proxy Remine to your apache server using the following code, this assumes redmine is at http://localhost:3000/

httpd.conf

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf, they are required.

ProxyRequests Off
ProxyPreserveHost On
ProxyPass / http://localhost:3000/
ProxyPassReverse / http://localhost:3000/

Add these lines to the end your apache httpd.conf , if you do this you will not be able to run any other stuff from your apache webserver because all requests will get forwarded to the Redmine server.

Or Alter the Redmine Server port directely

Simply run the Redmine server on port 80 by using the following switch which will give the same effect

-p 80 

Redmine in Subfolder

Method 1 - Basic (also blunt and site wide)

These instructions will assume the subfolder on apache you want is http://localhost/redmine/

.htaccess file

# Redirects /redmine to /redmine/
RedirectMatch ^/redmine$ /redmine/
RedirectMatch ^/$ /redmine/

add this code to ..../htdocs/.htaccess in your apache server.

You can redirect the non-slashed version, but this is to make sure we have a correct URL. A directory is denoted by having a slash at the end of the URL (ie /redmine/ ) wheresas if you dont, it denotes a page (ie /redmine ).

What we are directing to is more akin to a directory/default index file like a normal webserver, http://www.example.com/ You dont often see http://www.example.com/index.html , but they are the same page. Notice the slash at the end, this is intentional.

httpd.conf

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf, they are required.

ProxyRequests Off
ProxyPreserveHost On
ProxyPass /redmine/ http://localhost:3000/redmine/
ProxyPassReverse /redmine/ http://localhost:3000/redmine/

This is code that actualy passes the information/request between Redmine Server and your Apache server.

• ProxyRequest - This function provides forward proxying services and is not required here. This will prevent abuse of your server.
  php - Apache ProxyRequest - Server Fault - not required for reverse proxies, this must be off
  ProxyRequests Off - not working and httpd being abused as forward proxy | Apache | Users - turns of forward proxy requests
• ProxyPreserveHost - keeps header information in the request sent to the Redmine Server so things work nicely. If you want more information about this use google.
• ProxyPass and ProxyPassReverse - these handle the proxy mappings.

Can I make this Better

The commands above will work site wide so are a bit blunt, the following methods will allow you to apply these rules to a specific locations.

Method 2 - <Location>

<Location> works on the URLs presented to the server

httpd.conf

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf, they are required.

ProxyRequests Off	
<Location /redmine/>
	RedirectMatch ^/redmine$ /redmine/
	RedirectMatch ^/$ /redmine/
	ProxyPreserveHost On
	ProxyPass http://localhost:3000/redmine/
	ProxyPassReverse http://localhost:3000/redmine/
</Location>

• ProxyRequests Off will not work in <Location>
• Notice that the proxy statements do not have a target in them, only the source
• The RedirectMatch commands will work outside of <Location>
• rules in <location> can be moved easier that <directory> because there are not absolut addresses

With this method you have to split the commands, ProxyRequests will not work in location so needs to be put in the normal flow of the httpd.conf (i.e. not in <location>)

Method 3 - <Directory>

Directory works on the physical path of the accessed files and is better to be used for security because several URLs can point to a single directory or file whereas the <Directory> command is very specific.

httpd.conf

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf, they are required.

ProxyRequests Off
<Directory "d:\Documents\Developer\xampp\htdocs\redmine\">
	RedirectMatch ^/redmine$ /redmine/
	RedirectMatch ^/$ /redmine/
	ProxyPreserveHost On
	ProxyPass http://localhost:3000/redmine/
	ProxyPassReverse http://localhost:3000/redmine/
</Directory>

• ProxyRequests Off will not work in <Location>
• Notice that the proxy statements do not have a target in them, only the source
• <Directory "D:/Documents/Developer/xampp/htdocs/redmine/"> is also valid
• this command acts on the Virtual Directory in the xampp public folder
• This should work even though the directory does not exist
• The RedirectMatch commands will work outside of <Directory>

Method 4 - VirtualHost

With Virtualhost you can run a another domain name on the 1 xampp/apache server. This is very useful. You can also just use it to apply rules to the server and keep the code neater, easier for copying and pasting.

httpd.conf

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf, they are required.

<VirtualHost *:80>

	## This is for setting a domain name
	ServerName rails.localhost.com
	DocumentRoot "D:\Documents\Developer\RubyRoot\redmine\public\"

	# Make sure there is a trailing slash in the root
	RedirectMatch ^/redmine$ /redmine/
	RedirectMatch ^/$ /redmine/
	
	# The proxying code
	ProxyRequests Off 
	ProxyPreserveHost On
	ProxyPass /redmine/ http://localhost:3000/redmine/
	ProxyPassReverse /redmine/ http://localhost:3000/redmine/

</VirtualHost>

• If you want to run another domain on you local webserver you need to add a rule to your Hosts file, ie 127.0.0.1 rails.localhost.com
• All the code required is contained within <VirtualHost> tags
• This code be used on the whole server or just an individual domain (depends if you define ServerName)

Including the rules in the <VirtualHost> tags is not required but can make handling the code easier and if you do want apply this to a specific domain it is easy to enable it.

My Code

So you have arrived here at the code, just following the simple instructions and edit the files. Redmine will then run at http://localhost/redmine/ on you xampp installation. This does of course assume you have Redmine already running on your Windows PC.

Redmine - config.ru

# This file is used by Rack-based servers to start the application.
 
require ::File.expand_path('../config/environment',  __FILE__)
map '/redmine' do
  run RedmineApp::Application
end

Replace the contents of {redmine}/config.ru with this code. This also assumes you have not already made any alterations to this file.

Redmine - enviroment.rb

ActionController::Base.relative_url_root = '/redmine'

Add this to the end of {redmine}config/enviroment.rb. I also think you can put this in either development.rb or production.rb, this change will then only occur in that particular enviroment.

Apache / Xampp - httpd.conf

Edit your Apache / Xampp httpd.conf file

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

Make sure these modules are enabled in httpd.conf file, they are required.

#################################
# RUBY SETUP
#################################

	# Enforces a trailing slash for the /redmine/ directory
	RedirectMatch ^/redmine$ /redmine/
	RedirectMatch ^/$ /redmine/
	
	# The proxying code
	ProxyRequests Off 
	ProxyPreserveHost On
	ProxyPass /redmine/ http://localhost:3000/redmine/
	ProxyPassReverse /redmine/ http://localhost:3000/redmine/

#################################
# RUBY SETUP
#################################

Add these lines at the bottom of the httpd.conf file.

Done

All the changes are now done, you will find that Redmine will be served from http://localhost/redmine/ and http://localhost:3000/redmine/ , this is normal.

If you had your servers running while making these changes you need to restart them both.

You should note that this setup is non-SSL version so is not secure.

General Links

These are the links i used for my research and might be of use.

Redmine / Ruby

• HowTo Install Redmine on subdirectory (sub-URI) on Apache - Redmine
• Defect #11881: FCGI mode does not support sub-URI - Redmine
• Defect #12102: Installed Redmine in a sub-URI: Links are generated not correctly - Redmine - This is where i got the proper subdirectory code that works and also has the code for SSL usage
• Subdirectory problem with Redmine 2.1.2 under Windows - Redmine - Run Redmine in a subfolder using the Thin Server
• HowTo Install Redmine in a sub-URI - Redmine - The official page to get Redmine in a sub-URI / Sub-directory. It is dated and uses the mongrel server to work
• HowTo Install Redmine in a sub-URI on Windows with Apache - Redmine - Again this uses Mongrel and the instructions are probably out of date
• HowTo have both development and production environment available from Apache with VirtualHost - Redmine
• Apache2 + passenger configuration - Redmine
• Redmine not working properly from a subdirectory - Redmine - An unsuccessful attempt to run Redmine in a sub directory but they did get some things right
• Thin - yet another web server - Homepage of the Thin Server
• How do I configure Apache 2.2 for Ruby on Rails in Windows? - Stack Overflow
• apache 2.2 - How to configure Apache2 for Redmine properly? - Server Fault - Useful setup info for redmine suing apssenger on Debian Linux
• apache 2.2 - Virtualhost setup for Ruby on Rails application (mod passenger) - Server Fault
• Apache configuration for installing Redmine in URL subdirectory - Stack Overflow - mentions Phusion Passenger and the appropriate configuration
• Changing the base URL for Rails 3 development - Stack Overflow - This also has the correct subfolder fix for Redmine

Reverse Proxy

• Running a Reverse Proxy with Apache
• Using mod_rewrite for Proxying - Apache HTTP Server Version 2.2
• Using mod_rewrite for Proxying - Apache HTTP Server Version 2.4
• mod_proxy_html - Apache HTTP Server Version 2.4
• Running a Reverse Proxy in Apache
• mod_proxy - Apache HTTP Server Version 2.2
• How to set up a proxy server with XAMPP on Windows
• Use mod_rewrite’s proxy flag with caution — statichtml.com
• reverse proxy - Setting Redmine path - Server Fault - uses ProxyHTMLMap command, not sure if this alters hyperkinks in the content
• apache - ProxyPreserveHost seems to do little for me - Stack Overflow explains a little about ProxyPreserveHost in simple terms
• apache - Can ProxyPass and ProxyPassReverse work in htaccess? - Stack Overflow - No you cant, and this tells you why
• xampp - How can I enable mod_proxy_http - Server Fault - mentions security when using Proxy
• Apache config and .htaccess - URL rewriting - Reverse Proxy
• Configuring Ruby On Rails App in a subdirectory under Apache - Stack Overflow
• mod rewrite - Apache rewriterule with proxyPass and proxyPassReverse - Stack Overflow

Apache

• VirtualHost Examples - Apache HTTP Server Version 2.2
• Difference between and Apache directives - Server Fault
• <Directory> Directive - Official Documentation
• <VirtualHost> Directive - Official Documentation
• <Location> Directive - Official Documentation
• Rewriting URLs in hyperlinks (Configure Apache as a reverse proxy) - This article discuss rewriting hyperlinks in the source before serving the code and how this can take a lot of processing
• Apache's features to manipulate URL's
• mod rewrite - Apache mod_rewrite internally to different port - Stack Overflow
• apache 2.2 - How to configure Apache2 for Redmine properly? - Server Fault - this mentions Passenger and RailsBaseURI

These are my instructions to upgrade your Redmine install on windows and also assumes you have used my instructions for installing redmine, however this is not mandatory but will explain where the filepaths come from.

I will be upgrading Redmine 2.6.1 to Redmine 3.0.0 but i am sure they will be almost the same for other version.

Notes

• These instructions are based on the official instructions from RedmineUpgrade - Official Instructions.
• Redmine 3.0.0 now uses mysql 6.1.5
• the gems are installed to the RubyInstallere and not Redmine

Instructions

Step 1 - Check Requirements

The first step to upgrading Redmine is to check that you meet the requirements for the version you're about to install.

You can easily check what version of Redmine, Ruby and Rails by browsing to Administration/Information and you will see the following information.

Environment:
  Redmine version                2.6.1.stable
  Ruby version                   2.1.5-p273 (2014-11-13) [i386-mingw32]
  Rails version                  3.2.21
  Environment                    production
  Database adapter               Mysql2
SCM:
  Subversion                     1.8.11
  Filesystem                     
Redmine plugins:
  no plugin installed

Redmine 3.0.0 requires, Ruby 1.9.3 or higher (and now supports ruby 2.2).

Step 2 - Backup

1. Backup your redmine database via phpmyadmin (or any other method you prefer)
2. make a full backup of your redmine directory (ie D:\Documents\Developer\RubyRoot\redmine\)

Step 3 - Perform the upgrade

1. If Redmine is running, gracefully stop redmine, the redmine service if running and any related xampp installation (ie D:\Documents\Developer\xampp)
2. Download the following software
   • Redmine 3.0.0 - I chose the .zip to make it easier for extracting
   • mysql-connector-c-6.1.5-win32.zip - this is the MySQL connector
3. Rename
   D:\Documents\Developer\RubyRoot\redmine\
   to
   D:\Documents\Developer\RubyRoot\old-redmine\
4. Extract redmine-3.0.0.zip to D:\Documents\Developer\RubyRoot\redmine
   
5. From the '.../old-redmine/' directory, copy the following files to the same location in the new redmine installation '.../redmine/'
   
   • {redmine}/config/database.yml
   • {redmine}config/configuration.yml
   • {redmine}/files/ directory content (this directory contains all your uploaded files so you might not have any).
   • The folders of your custom plugins from your plugins directory (or vendor/plugins directory if upgrading from a 1.x version) into new installation plugins directory. Make sure that you copy only plugins that are were not initially bundled with your previous Redmine setup. My installation does not have any plugins so this step is not needed.
   • If you are running Redmine in a subfolder
     • {redmine}/config/environment.rb (this might require merging rather than copying)
     • {redmine}/config.ru (this might require merging rather than copying)
   • If you have the redmine service copy the following files
     • redmine_service_ctl.rb
     • redmine_service.rb
6. Open up a command prompt as an administrator and navigate to D:\Documents\Developer\RubyRoot\redmine
7. Install the required gems by running the following command:

   bundle install --without development test

   • this installs all the required gems
   • this brings up the following message about the new version of the MySQL connector that has been installed
     

     ================================================================================
     
       You've installed the binary version of mysql2.
       It was built using MySQL Connector/C version 6.1.5.
       It's recommended to use the exact same version to avoid potential issues.
     
       At the time of building this gem, the necessary DLL files were retrieved from:
     
       http://cdn.mysql.com/Downloads/Connector-C/mysql-connector-c-6.1.5-win32.zip
     
       This gem *includes* vendor/libmysql.dll with redistribution notice in vendor/README.
     
     ================================================================================

   • You need to extract  libmysql.dll from mysql-connector-c-6.1.5-win32.zip. The file is located in the archive at ...\mysql-connector-c-6.1.5-win32\bin
   • Replace D:\Documents\Developer\RailsInstaller\mysql\lib\libmysql.dll with the new version of libmysql.dll
   • you might need to reboot windows for the new version of libmysql.dll to be loaded
8. Run the following command from your new Redmine root directory:

   bundle exec rake generate_secret_token

9. Check for any themes that you may have installed in the public/themes directory. You can copy them over but checking for updated version is ideal.

Step 4 - Update the database

1. Start your xampp install apache and mysql
2. This step is the one that could change the contents of your database. Go to your new redmine directory, then migrate your database:

   bundle exec rake db:migrate RAILS_ENV=production

3. If you have installed any plugins, you should also run their database migrations:

   bundle exec rake redmine:plugins:migrate RAILS_ENV=production

Step 5 - Clean Up

1. Clear the cache and the existing sessions:

   bundle exec rake tmp:cache:clear tmp:sessions:clear RAILS_ENV=production

2. Restart the application server (e.g. puma, thin, passenger)
3. Finally go to "Admin -> Roles & permissions" to check/set permissions for the new features, if any.

Links

• RedmineUpgrade - Official Instructions
• [OLD] Guide: How to Upgrade Redmine to Latest Version (2.0.3+) Painlessly | TurnKey GNU/Linux Forum
• Upgrading your Bitnami Redmine Install (Windows) | Chris McKee

Changing the Logging Level

If you discover that your log file is filling up with lots of uneeded information you can change the logging level from the default.

in the {redmine}/config/additional_enviroment.rb file you can change the logging level. By either adding the line or un-remming one that is present. When you set the error loggin level to error you will only get errors logged to the log file. This will affect both enviroments.

• config.log_level = : debug
• config.log_level = : error

The log levels available are: :debug, :info, :warn, :error, :fatal, and :unknown, which correspond to the integers 0-5.

Logging Links

• ruby on rails - Turn off active record logging in production - Stack Overflow
• How do I turn off logging in Rails 3?Jason Noble's Technical Adventures | Jason Noble's Technical Adventures
• how to disable annoying asset-related log messages in rails - Übergeek UnLtd
• Turn off asset logging in your Rails application - Freelance software engineer - Michaël Rigart - uses Quiet_assets GEM
• Rails disable logging of asset pipeline messages : Max Ivak Personal Site
• How to disable logging of asset pipeline (sprockets) messages in Rails. - Codebeerstartups
• How to: How to disable logging of asset pipeline (sprockets) messages in Rails 3.1? | SevenNet
• RoR Guide & Solutions: Solution to turn off Rails asset pipeline log in Rails 4 development log file
• Logging configuration - Redmine Thread
• installation - how to enable redmine (ruby on rails) logging? - Server Fault
• Disable Rails 3.1 SQL logging - Stack Overflow

Installation of Subversion with redmine can be straight forward if you have some easy toread instructions, so here they are.

There are several levels of integration

Basic SVN Integration

• browse SVN Repositories
• close jobs via SVN commit messages
• compare revisions

Read the official Instructions - RedmineSettings - Repositories

According to the instructions this only works if Redmine and the Subversion Server are on the sam physical machine (this needs 100% clarifying but for now we will assume it is true).

This feature allows you to grab the commits from a predefined SVN Repository (most protocols are supported) and this repository is attached to a project, by doing this when you submit a commit to a repository with a message with correct issue reference syntax, redmine will close the related isse(s) in the project. Git , SVN and other SCM are available. This feature also allows you to perfomr comparisons of different revisions and you eben get the choice to see the changes side-by-side or on top of each other, this feature can be useful depending on how your code looks. There is also a repository browse feature built in to redmine. You can have multiple repositorys per project

Enable Fetch Commits Automatically

In Redmine Administration/Settings/Repositories make sure that Fetch Commits Automatically is ticked. If this option is activated, the application automatically retrieves the new revisions when a user consults the repository.

Official article here

Instructions to add a repository

make sure u use a network version for the repository so you can move it if you want.

• create a project
• In the project settings, make sure that the 'Repository' module is enabled and go to the 'Repository' tab.
• Select the SCM that corresponds to your repository and enter the path or URL of your repository.
• i used these settings, Redmine was able to download the changes from the repository

SCM Subversion
Main repository checked
identifier test-identifier (dont know what this is for, Repository Identifier)
URL https://svn.exampleserver.com:18080/svn/Test/
user svn-redmine
password xxwhateverxxxx

* when the repository is set you cannot change the details after you have created it except for the surname and password.I have read on the redmine official documentation that you should use a network location for you Subversion repository

• the first time you view the repository redmine will retrieve all of the changes and import the information

Now that you have configured these settings you can close jobs via a svn commit (see below for forming a correct message for closing jobs) but the draw back is that the changes/commits are only retrieved at certain times

1. when you browse the SVN repository via Redmine
2. if you set up a CRON job {add details here}

Allow SVN Commits to Close Jobs

In the step above you configured Redmine to interact with Subversion and to retrieve any changes/commits. Redmine currently parses the commit messages for keywords which reference issue, it does this so it can automatically change these keywords into links. These links are found by using a set of default rules and keywords which can be chamged in the admin panel but the default options should be fine for most people.

The one thing Redmine does not do by default is close issues. You need to specify the keywords that you want to be used as closing keywords and enable the option in the Redmine settings via the admin panel.

Links

• RedmineSettings -Referencing issues in commit messages - Official Article
• Community: T.C. Plomp's Blog: Automatically updating Redmine from Rhodecode - National Instruments

What Should i Do?

1. Browse to Administration/Settings/Repositories/'Referencing and fixing issues in commit messages' Section
2. Enable 'Allow issues of all the other projects to be referenced and fixed'
3. Add the following into 'Fixing keywords'
   

   fix,fixes,fixed,close,closed,patches,patched

   
   If i get a better list i will add it here, but these keywords give you the gist.
   
   
4. Set 'Applied Status' to Closed
5. Set '% Done' to 100%
6. Click Save at the bottom left of the page to save all changes
7. Done

You can configure whatever rule you want but at least this will get you going. Read the official Documentation for the syntax of closing statements you should use in your commit messages.

NB:

• I do not know if the keywords are case sensitive

Advanced Keywords

Better Issue Referencing

Redmine has a list of keywords it scans for to identify issues as follows:

refs,references,IssueID

I want to extend that to the following list

refs,references,IssueID,bug,bugs,defect,defects,feature,features,issue,issues,patch

I dont know about whether yoou can close multiple issues but i will add the plural version here anyway

Resolve Issue Keywords (optional)

These are different status and have different uses so require their own settings in the'Referencing and fixing issues in commit messages'.

If you want to have the resolved option set from commit messages you need to do the following:

1. Browse to Administration/Settings/Repositories/'Referencing and fixing issues in commit messages' Section
2. Add a new 'Fixing' rule
3. Add the following into 'Fixing keywords'
   

   resolve,resolves,resolved

4. Set 'Applied Status' to Resolved
5. Set '% Done' to 100%
6. Click Save at the bottom left of the page to save all changes
7. Done

Example Commit Message Syntax for Redmine

To reference and issue use a command using any of the issue referencing keywords as below:

issue #1234

To close a job use the following or similiar command with any of the other closing keywords

close #1234

The key thing with these is that that the command is in a certain format

{keyword}{a space}{a hash}{issue number}

Resolved Vs Closed Links

• What is the difference between closed and resolved status in GreenHopper? - Atlassian Answers
• Feature #11313: Automatic closing of resolved issues - Redmine
• Marking issue Resolved vs Closed - Redmine

Close Jobs Imediately Upon SVN Submit

To get jobs to close when you actually submit the commit further integration is required which is in the next section.

This is a very useful feature because in my opinion this is how everyone will think this integration works, when you submit a commit with closing statements in the message that issue will be immediately closed. In the 'Basic SVN Integration' this does not happen until you browse the repository or your cron job is fired so the commits get parsed and redmine closes the jobs so there could potentially be a gap between closing the jobs and this apopearing on the Redmine installation.

In this method you basically create a post-commit hook that polls the Redmine installation which then instructs Redmine that some changes have been made and that it should fetch them. It should be noted that this can cause a slight slow down in the commiting of the changes to the repository.

There are 2 types of polls you can use:

1. Fetches changesets for all active projects
   
   /sys/fetch_changesets?key=<your service key>
   
   
2. Fetches changesets from the repository of a specific project. This will be quicker that the previous method.
   
   /sys/fetch_changesets?id=<project identifier>&key=<your service key>
   
   

And several delivery methods for the hook:

1. Visual Basic (.vbs)
2. wget
3. cURL
4. Ruby (via command line)

My Instructions

I will be using cURL for these instructions because it is the easiest solution.

Do this once

1. Download the correct cURL Binary from here. Get the Generic Non-SSL version for your architecture (x86/x64), security will be addressed in a later article
2. Copy the file to D:\Documents\developer\SubversionEdge\bin - this folder should be in your path from when you installed Collabnet Subversion Edge. You can put this file anywhere but if it is not in your path you need to use the full location of the executable or add that location to your path.
3. Disable Fetch Commits Automatically - there is no point in fetching changes upon browsing the repository from within redmine if your changes are always upto date.
   • You make this change by going to Administration/Settings/Repositories/Fetch commits automatically and untick this option.
     
4. Enable Enable WS for repository management - This allows the Webservice to be used for triggering refreshes.
   1. You make this change by going to Administration/Settings/Repositories/Fetch commits automatically and tick this option.
   2. 'Genereate a Key' for the WS Services
5. Save Changes

Required For Each Repository

For each repository you need create add an exectuable post-commit hook with the commands in it to trigger Redmine in to checking for changes. I will use a Hook that updates only the repositories in that particular project. It will also be very easy to change to refresh all repositories.

post-commit.bat

@ECHO OFF

curl "http://<redmine url>/sys/fetch_changesets?id=<project identifier>&key=<your service key>" 

This is the example code from Redmine's official instructions on calling a URL that will trigger Redmine to refresh all Repositories for that chosen Project.

Create the 'post-commit' Hook

I will assume

• you have created a test repository called 'Test' and it is physically located at D:\Documents\developer\SubversionEdge\data\repositories\Test
• Redmine is located at http://localhost/redmine/
• Your project in Redmine is called 'TestProject'
• Your WS Key that you generated earlier is 'Password123'

@ECHO OFF

curl "http://localhost/redmine/sys/fetch_changesets?id=TestProject&key=Password123" 

1. create a file called post-commit.bat
2. edit this file and add the code above in to it and save.
   NB: if the repository you are updating is in another project you will need to alter the project name accordingly, you cannot just copy the Hook file into another repository.
   
   
3. Move this file to D:\Documents\developer\SubversionEdge\data\repositories\Test\hooks
4. Done

Upon a successful commit to your Subversion Repository, Redmine will check all of the Repositories that belong to the specified project for changes.

You might be asking why cannot i not just update only a specified repository in Redmine rather than all of the repositories that belong to a project. This is a requested feature but for some reason it has not been added yet. Considering things most people will not notice this and if you use the command that refreshes all repositories in Redmine upon a successful commit you will never need this. If you use the 'Refresh All' command you can just copy this to other repository hook folders without alteration.

Useful Links

• HowTo setup automatic refresh of repositories in Redmine on commit - Official instructions on Redmine.org
• Community: T.C. Plomp's Blog: Automatically updating Redmine from Rhodecode - National Instruments
• A Redmine hook for repo updates - Zane's Blog
• Matisse's Blog: Redmine - Fixed for Large SVN Repository

Automatically Create SVN Repositories

This is the final level of integration but it is not easy and seems to come with its own issues. You have to edit code and do this and that to get it to work. It is quicker to create the SVN Repository in Subversion Edge and then enter the details into redmine as in 'Basic SVN Integration'

I will not be implementing this aas i have easy control over my Subversion Server

See the official page for more information

• HowTo configure Redmine for advanced Subversion integration - Redmine
• HowTo Automate repository creation - Redmine
• Repositories access control with apache mod dav svn and mod perl - Redmine
• HowTo to handle SVN repositories creation and access control with Redmine (part 1)- Redmine
• HowTo to handle SVN repositories creation and access control with Redmine (part 2) - Redmine

Installing Redmine as a Service

This can be a tricky thing to get working if you have no knowledge of Ruby or assume that all the scripts you come across actually work. I have found a lot of information about getting Redmine to run as a windows service is quite old and ruby ahs changed a lot since they were written. This article hold all my research from googling around the internet which includes those key niggets of information to help me get the scripts working.

As ever you have come across another article saying how things should work but never just give you the code so you can get Redmine working and worry about other things. This article is diffrerent, i have included all my research so if there are any problems i have not seen or issues that come along later you will be able to fix them withou pulling your hair out and lastly this article has the working scripts. If you just want the scripts so you can get running please scroll to 'The Scripts' and follow the installations instructions and you will be running very quickly.

Notes

General

There are currently a few methods that I have found to create a service:

1. Mongrel server – seems old way of doing it
2. Creating a registry entry via a script and then a payload script with the service code
3. Create the service utilising the windows resource kit by having another program run as a wrapper
4. Simple – create the service by the command line pointing to your script

• Read this article on how to install redmine as a service. It is really easy to follow
  http://www.redmine.org/projects/redmine/wiki/HowTo_run_Redmine_as_a_Windows_service_%28win32-service_+_taskill_approach%29
• Your Redmine directory is - D:\Documents\Developer\RubyRoot\redmine
• Your ruby directory - D:\Documents\Developer\RailsInstaller\Ruby2.1.0
• The command to create the service is:
  sc create redmine binPath= "D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw -C D:\Documents\Developer\RubyRoot\redmine\ service.rb"Notes

• You might need to run this as administrator
• This creates a service called redmine
• When created it is set as Manual, you need to change this to automatic - I think!
• sc delete redmine will delete the service
• creates a log file in {REDMIN_DIR}\log
• my code - sc create redmine binPath= "D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw -C D:\Documents\Developer\RubyRoot\redmine\ service.rb"
• should there be a space at …..redmine\ service.rb
• these instructions will only set Redmine as a service not all the rails
• The script of stack overflow don’t forget to change the CONFIG statement, see thread
• Irb / IRb= iteractive ruby winapi - Ruby: gem win32-service: Create a service with Admin privileges - Stack Overflow
• notes for the win32-service.gem is in its gem folder under docs which ill give the syntax for using the gem
• most commands seem to want to run from the project directory - check steps and add reminders where needed.
• i think where you run the 'rails server' command denotes the root folder of the ruby server
• unless specified the current directory will be 'c:\windows\system32\'
• Ruby.exe is the base binary and rubyw.exe is a version that does not present a console which is better because it can run silently.
• task kill method works if you do not stop the service to early and i need to add the addition of server.pid delete statement
• unless you change it the default directoy is c:\windows\system32, you can change it on the service command line prompt with the -C option or in the script with the :chdir or Dir.chdir
• remember running scripts and things from the command prompt will give you more information

When happens when you run the Redmine service

When you start the service it can take up to 60 seconds to properly start and if you look in task manager it is normal to see to instances of ruby either ruby.exe or rubyw.exe

This is what happens:

1. when you start the windows service this spawns 1 instance of rubyw.exe in windows
2. the windows service loads the ruby script service.rb and executes it, this the causes antoher instance of rubyw.exe to appear in the windows service list
3. the webrick server starts creates and populate the /tmp/pid/server.pid with its process id
4. redmine starts it then replaces the number in server.pid with its own number
5. servider.pid is created with redmines PID inside (server.pid is the default)
6. you can see the rubyw.exe is running at about 5% CPU
7. when the rubyw.exe (with no usage on redmine) drops to 0% the server is running and it is safe to stop the redmine server if required

Errors

When trying to configure redmine to run as a service you might come across some of the issues I am going to outline below but the good thing is I am going to tell you why they occur which will make fixing them stress free.

Error 1053

Windows could not start the redmine service on Local Computer.

Error 1053: The service did not respond to the start or control request in a timely fashion.

• This occurs when there are issues in the script or in particular the binary path definition in the windows service (ie the one you create with the 'sc create' command)
• When you start the service and it immediately fails it is most likely the binary path statement.
• If it fails a little way in it is most likely the spawn.process file path is wrong.
• not pointing to the ruby/rubyw binary correctly (ie full location)
• not pointing to the script correctely (ie full location)
• not changing to the script directory (ie -C or :chdir)
• faulty script, ie written wrong
• a previously run script has left a server.pid file in the /tmp/pid/ folder which prevents the daemon spawning
• possibly incompatible builds of win32-services gem

Error 1067

Windows could not stop the redmine service on Local Computer.

Error 1067: The process terminated unexpectedly.

• This can be caused by trying to close the service too quickly after starting it.
• If you get this message after the service has started correctely and been running for a while and then you stop it the error occurs this is most likely to be you exit code is in correct, perhaps not terminating the correct pid.

Links

Normal Script

• how to configure a rails app (redmine) to run as a service on windows? - Stack Overflow - this is the DemoDaemon script and the basis of my script (and the task kill script from redmine.org)
• Create a Windows Service with Ruby - Part 1 - this is a very clear article on how to install a ruby app as a service (written 23/07/13). You can download his code from github. Even thought it is for a ruby app it is the same code for redmine (almost). This code has a main script code and some smaller ones for registering and unregistering the service. The service is configured to run under the 'network' user for running without a logged in user.
  It mentions the use of:
  • run as 'network' user - to allow the service to run without a user being logged in
  • chomp - The chomp method simply removes any leading or trailing whitespace
  • 'echo %cd%' - displays the current directory
  • -C - This option specifies that Ruby should set the working directory of the script to the directory where the script is located.
• win32 daemon error - Service_Main thread exited abnormally · Issue #4 · djberg96/win32-service · GitHub - this is the 1 file version of the DemoDaemon script
• Sinatra deployed as a windows service [updated] | tech.maynurd.com - a bit old and for something called Sinatra but gives some useful context
• Running a Ruby Program as a Windows Service? - Stack Overflow - this uses code from 'Create a Windows Service with Ruby - Part 1'
• winapi - Ruby: gem win32-service: Create a service with Admin privileges - Stack Overflow
• Win32::Daemon#mainloop method - win32-service (0.8.6) ruby gem documentation - Omniref - this shows you information about win32-service.gem
• winapi - Daemon creation not working using Win32Utils ruby gem - Stack Overflow - usesful insight into error 1053
• Rails Deployment Environment on Windows - Stack Overflow - also covers setting up running rails app/redmine through apache
• ubuntu - How to stop a Daemon Server in Rails? - Stack Overflow
• Stop and Restart Easily a Rails Server - Waiting for dev...
• Ruby on Windows: FAQ: "script.rb" versus "script.rbw" - whatr is the difference between ".rb" and ".rbw" files, (ruby.exe vs rubyw.exe)
• Kill process by name using Ruby on Windows | Nat On Testing - taskkill
• ruby - require 'rubygems' - Stack Overflow - why we need or dont need it
• how to configure a rails app (redmine) to run as a service on windows? - Stack Overflow - mentions DemoDaemon script
• File: README - Documentation for win32-service (0.8.6) - docs for the win32-service
• win32-service | RubyGems.org | your community gem host - the official gem page for win32-service
• Ruby's File.open gives "No such file or directory - text.txt (Errno::ENOENT)" error - Stack Overflow - useful insight into the error and how to output the current directory in ruby

Using Windows Resource Kit

• how to configure a rails app (redmine) to run as a service on windows? | Zachman Answers
• Running Redmine as a Windows Service | Learn First
• Running Any Executable As A Windows Service (Ruby / Sinatra) - Everything is a Ghetto

Mongrel

• Muhammad Naeem: How To Install Redmine on Windows with Apache - this article covers installing redmine from scratch on windows using the mogrel service
• How to install Ruby on Rails alongside WampServer? - Stack Overflow - also covers setting up redmine through apache
• Step-by-step quick installation of Redmine + SVN on Windows | Rahul Vaidya's Blog

Misc Relevant

• Method: File.expand_path - Documentation for core (1.9.2)Method: File.expand_path - Documentation for core (1.9.2)
• Files & Directories (Read Ruby 1.9)
• The Rails Command Line — Ruby on Rails Guides
• How to start rails server? - Stack Overflow
• Run console command in ruby, get PID of child process and kill it in some seconds - Stack Overflow
• Module: Process (Ruby 1.9.3) - covers process.spawn and process.wait commands
• ruby on rails 3 - ROR + A server is already running. Check .../tmp/pids/server.pid. Exiting - Stack Overflow - has examples of how to set a different server.pid file and set a different port
• How to run any Ruby Script as a Windows 7/2008/Vista/2003/XP Service Daemon | AlwaysUp | Start Ruby at boot/on schedule - this is a 3rd party Service software to allow the running of any Ruby Script
• File.expand_path() - the ctl file sends error messages to windows, the daemon file sends error message to the log file

The Scripts

Simple Script

The simple script is the absolute basic version of the script but does work as expected.

These are my notes on using the script found on redmine.org, HowTo run Redmine as a Windows service (win32-service + taskill approach) - Redmine. This script has issues with it so i have listed them below and then you will find my corrected version which does work.

• This script will only run once and then you will get an error (1053) everytime you try an run it afterwards - This is because when thescript finishes it does not delete {redmine_dir}/tmp/pids/servere.pid which prevents it from running when ruby does a check for running processes. To fix this i added a line of code at the end to remove the server.
• when running after correctely setting the details in the script i was still getting a 1053 error. - This is caused because the file location for the spawn.process event needs to be a full address
• it will give a 1063 error when exiting - This can be caused by the exit! command, so i commented it out

Instructions

• Install the win32-service Gem. This is done by opening a command prompt (possibly with admin privileges and the internet) and typing: ruby gem install win32-service
• create a  file called redmine-service.rb putting in the script code below.
• Place this script the root folder of your redmine installation D:\Documents\Developer\RubyRoot\redmine\
• In the script update REDMINE_DIR path to fit your Redmine installation
• open up a command prompt with administrator priviledges and run the following command that will create the Windows Service. Edit the command where needed,  D:\Documents\Developer\RubyRoot\redmine\ is the path of the directory where the service.rb file is located and D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw your Ruby binary.

sc create redmine binPath= "D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw -C D:\Documents\Developer\RubyRoot\redmine\ redmine-service.rb"

When you fill in the command make sure you leave the space inbetween ...\redmine\ redmine-service.rb , the reason for this is that ...\redmine\ beongs with the -C switch which is telling the code to change to the redmine directory before running the script. you can actually add a full path to redmine-service.rb if you wanted to make it easier to read.

• You can now start and stop the Redmine Service through services.msc or these should work sc start redmine and sc stop redmine
• If you want to delete the service you can use sc delete redmine

The Script

REDMINE_DIR = 'D:\Documents\Developer\RubyRoot\redmine'
LOG_FILE = "#{REDMINE_DIR}\\log\\redmine-service.log" 

begin
  require 'win32/daemon'
  include Win32

  class RedmineService < Daemon

    def service_init
      File.open(LOG_FILE, 'a'){ |f| f.puts "Initializing service #{Time.now}" }     
	  @server_pid = Process.spawn 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw script/rails s -e production', :chdir => REDMINE_DIR, :err => [LOG_FILE, 'a']
    end

    def service_main
      File.open(LOG_FILE, 'a'){ |f| f.puts "Service is running #{Time.now} with pid #{@server_pid}" }
      while running?	  
        sleep 10
      end
    end

    def service_stop
		
		File.open(LOG_FILE, 'a'){ |f| f.puts "Stopping server thread #{Time.now} with pid #{@server_pid}" }  
		system "taskkill /PID #{@server_pid} /T /F"		
		Process.waitall
		File.open(LOG_FILE, 'a'){ |f| f.puts "Service stopped #{Time.now}" }
		pid_file = 'tmp/pids/server.pid'
		File.file?(pid_file) && File.delete(pid_file)
		#exit! # can cause a bad exit		  
    end
	
  end

  RedmineService.mainloop

rescue Exception => e
  File.open(LOG_FILE,'a+'){ |f| f.puts " ***Daemon failure #{Time.now} exception=#{e.inspect}\n#{e.backtrace.join($/)}" }
  raise
end

My Complex Script

This is my script that i have made from several scripts. This is a modern daemon code with logging and a controller file to make install/running/deleting the script as a service. The script will also populate most of the variables if your Ruby path is set and you run the redmine_service_ctl.rb from the root of your redmine installation.

My script might not handle paths with spaces in them correctely. This should be easily fixed by using quotes (") where needed. I might update the scripts if there is any interest.

Instructions

The script configures itself automatically.

• Install the win32-service Gem. This is done by opening a command prompt (possibly with admin privileges and the internet) and typing: ruby gem install win32-service
• redmine_service_ctl.rb file
  • create a file called redmine_service_ctl.rb putting the in the Controller Script code below.
  • Place this script the root folder of your redmine installation (eg: D:\Documents\Developer\RubyRoot\redmine\)
  • Edit the file as required
• redmine_service.rb file
  • create a file called redmine_service.rb putting the in the Daemon / Service Script code below.
  • Place this script the root folder of your redmine installation (eg D:\Documents\Developer\RubyRoot\redmine\)
  • Edit the file as required
• Install the service - Open up a command prompt with administrator priviledges and run the following command that will create the windows service.
  
  ruby redmine_service_ctl.rb install

If the installation does not work as expected you might need to

• check your ruby path exists
• that you have run this script from your redmine root folder
• the script might automatically run only if your configured MySQL service is already running but this will not affect installtion of the service.
• Edit the Scripts to insert manuall variables instead of relying on the auto variable code.

Controller Script

This script should be called redmine_service_ctl.rb and this is the service management script, it is used to install/stop/start/delete the service from the command line.

############################################################################
#
# redmine_service_ctl.rb
#
# This is a command line script for installing and/or running a small
# Ruby program as a service, in this case it is Redmine.
#
# The service will run Redmine and will record certain events to a log file.
# If enabled, the service can also write a small bit of text
# to the log file every 20 seconds to show it is running.
# Some text will bve written to the log file during the initialization (service_init) step.
#
# It should take about 10 seconds to start, which is intentional - it's a test
# of the service_init hook, so don't be surprised if you see "one moment,
# start pending" about 10 times on the command line.
#
# The Log File is {redmine_dir}/log/test.log.  Feel free to delete it when finished.
#
# To run the service, you must install it first.
#
# Usage: ruby redmine_service_ctl.rb <option>
#
# Note that you *must* pass this program an option
#
# Options:
#    install    - Installs the service.  The service name is "RedmineService"
#                 and the display name is "Redmine Windows Service".
#    start      - Starts the service.  Make sure you stop it at some point or
#                 you will eventually fill up your filesystem!.
#    stop       - Stops the service.
#    pause      - Pauses the service.
#    resume     - Resumes the service.
#    uninstall  - Uninstalls the service.
#    delete     - Same as uninstall.
#
# You can also used the Windows Services GUI to start and stop the service.
#
# To get to the Windows Services GUI just follow:
#    Start -> Control Panel -> Administrative Tools -> Services
#
# by shoulders @ QuantumWarp.com
# used code from 
# http://stackoverflow.com/questions/877943/how-to-configure-a-rails-app-redmine-to-run-as-a-service-on-windows
#
############################################################################

#---------------------------------------------------------------------------
# Includes
#---------------------------------------------------------------------------

	# require 'rubygems' # only for < ruby 1.9
	require 'win32/service'   
	require 'rbconfig'
	include Win32
	include RbConfig  

	# Make sure you're using the version you think you're using.
	puts 'VERSION: ' + Service::VERSION

	SERVICE_NAME 			= 'RedmineService'
	SERVICE_DISPLAY_NAME 	= 'Redmine Windows Service'			
	SERVICE_DESCRIPTION		= 'This is my Windows Redmine Service'
	
#---------------------------------------------------------------------------
# Automatically Create Windows Service Binary Path
#---------------------------------------------------------------------------

	RUBY_BINARY = File.join(CONFIG['bindir'], 'rubyw').tr('/', '\\')
	PATH = ' -C ' + File.dirname(File.expand_path($0)).tr('/', '\\') + '\\ ' + 'redmine_service.rb'
	CMD = RUBY_BINARY + PATH
	# MANUAL OVERIDE
	# This builds the windows binaryPath ="" in the format:
	# CMD = 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw -C D:\Documents\Developer\RubyRoot\redmine\ redmine_service.rb'
	# CMD = 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw -C D:\Documents\Developer\RubyRoot\redmine\ D:\Documents\Developer\RubyRoot\redmine\redmine_service.rb'
	
	# if you want to uses spaces in your path you need to enclose in each path in quotes  ("")
	# possibly
	# CMD = '"D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw" -C "D:\Documents\Developer\RubyRoot\redmine\ " "redmine_service.rb"'
	# CMD = '"D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw" -C "D:\Documents\Developer\RubyRoot\redmine\" "D:\Documents\Developer\RubyRoot\redmine\redmine_service.rb"'
	
#---------------------------------------------------------------------------
# Perform Service Action Based on Argument supplied
#---------------------------------------------------------------------------
   
# You must provide at least one argument.
raise ArgumentError, 'No argument provided' unless ARGV[0]

# These are the actions performed for the various windows service tasks/functions
case ARGV[0].downcase   

  when 'install'
	 Service.new(
		# These are the service configuration settings that are written to the registry
		# will run automatically without a user being logged in
		:service_name     => SERVICE_NAME,			
		:display_name     => SERVICE_DISPLAY_NAME,			
		:description      => SERVICE_DESCRIPTION,            
		:start_type       => Service::AUTO_START,
		:service_type     => Service::WIN32_OWN_PROCESS,
		:load_order_group => 'Network',			
		:dependencies     => nil,
		#:dependencies     => ['Developer-Apache2.4','Developer-MySQL'],
		#:error_control    => Service::ERROR_NORMAL,
		#:service_start_name => 'SomeDomain\\User',
		#:password         => 'XXXXXXX',
		:binary_path_name => CMD,
	 )
	 puts CMD
	 puts 'Service ' + SERVICE_NAME + ' installed'
	 
  # One of following code sections, which all match to their corresponding 'Windows Service Function' is
  # triggered depending on what argument is supplied in the oommand line.
  
  when 'start'
	 if Service.status(SERVICE_NAME).current_state != 'running'
		Service.start(SERVICE_NAME, nil, 'hello', 'world')
		while Service.status(SERVICE_NAME).current_state != 'running'
		   puts 'One moment...' + Service.status(SERVICE_NAME).current_state
		   sleep 1
		end
		puts 'Service ' + SERVICE_NAME + ' started'
	 else
		puts 'Already running'
	 end
	 
	 
  when 'stop'
	 if Service.status(SERVICE_NAME).current_state != 'stopped'
		Service.stop(SERVICE_NAME)
		while Service.status(SERVICE_NAME).current_state != 'stopped'
		   puts 'One moment...' + Service.status(SERVICE_NAME).current_state
		   sleep 1
		end
		puts 'Service ' + SERVICE_NAME + ' stopped'
	 else
		puts 'Already stopped'
	 end
	 
	 
  when 'uninstall', 'delete'
	 if Service.status(SERVICE_NAME).current_state != 'stopped'
		Service.stop(SERVICE_NAME)
	 end
	 while Service.status(SERVICE_NAME).current_state != 'stopped'
		puts 'One moment...' + Service.status(SERVICE_NAME).current_state
		sleep 1
	 end
	 Service.delete(SERVICE_NAME)
	 puts 'Service ' + SERVICE_NAME + ' deleted'
	 
	 
  when 'pause'
	 if Service.status(SERVICE_NAME).current_state != 'paused'
		Service.pause(SERVICE_NAME)
		while Service.status(SERVICE_NAME).current_state != 'paused'
		   puts 'One moment...' + Service.status(SERVICE_NAME).current_state
		   sleep 1
		end
		puts 'Service ' + SERVICE_NAME + ' paused'
	 else
		puts 'Already paused'
	 end
	 
	 
  when 'resume'
	 if Service.status(SERVICE_NAME).current_state != 'running'
		Service.resume(SERVICE_NAME)
		while Service.status(SERVICE_NAME).current_state != 'running'
		   puts 'One moment...' + Service.status(SERVICE_NAME).current_state
		   sleep 1
		end
		puts 'Service ' + SERVICE_NAME + ' resumed'
	 else
		puts 'Already running'
	 end
	 
	 
  else
	 raise ArgumentError, 'unknown option: ' + ARGV[0]
end

Daemon / Service Script (the actual service)

This should be called redmine_service.rb

############################################################################
#
# redmine_service.rb
#
# This script should automatically configure itself.
# 
# The only thing you might need to alter are the RUBY_BINARY_ARGUMENTS.
# -e is the enviroment and the options are development/production
# -p is the port number to run Redmine on
#
# by shoulders @ QuantumWarp.com
# used code from
# http://stackoverflow.com/questions/877943/how-to-configure-a-rails-app-redmine-to-run-as-a-service-on-windows
#
############################################################################

#---------------------------------------------------------------------------
# Includes
#---------------------------------------------------------------------------

	include RbConfig 

#---------------------------------------------------------------------------
# Automatically Create File Paths
#---------------------------------------------------------------------------

	RUBY_BINARY = File.join(CONFIG['bindir'], 'rubyw').tr('/', '\\')
	#RUBY_BINARY = 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw'

	# Redmine 2.x
	#RUBY_BINARY_ARGUMENTS = ' ' + 'script/rails s -e production -p 3000'
	#RUBY_BINARY_ARGUMENTS = ' script/rails s -e production -p 3000'

	# Redmine 3.x
	RUBY_BINARY_ARGUMENTS = ' ' + 'bin/rails s -e production -p 3000'
	#RUBY_BINARY_ARGUMENTS = ' bin/rails s -e production -p 3000'
	
	REDMINE_DIR = File.dirname(File.expand_path($0)).tr('/', '\\')
	#REDMINE_DIR = 'D:\Documents\Developer\RubyRoot\redmine'

	LOG_FILE = "#{REDMINE_DIR}\\log\\redmine-service.log" 
	#LOG_FILE = 'D:\Documents\Developer\RubyRoot\redmine\log\redmine-service.log'

#---------------------------------------------------------------------------
# The Actual Service
#---------------------------------------------------------------------------  

begin  
    
    require 'win32/daemon'
    include Win32

    class RedmineDaemon < Daemon       
        # This method fires off before the +service_main+ mainloop is entered.
        # Any pre-setup code you need to run before your service's mainloop
        # starts should be put here. Otherwise the service might fail with a
        # timeout error when you try to start it.
        #
        def service_init
		
			File.open(LOG_FILE, 'a'){ |f| f.puts "Initializing service #{Time.now.to_s}" }
			
			@server_pid = Process.spawn RUBY_BINARY + RUBY_BINARY_ARGUMENTS, :chdir => REDMINE_DIR, :err => [LOG_FILE, 'a']
			
			# MANUAL COMMANDS
			# Redmine 2.x
			#@server_pid = Process.spawn 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw script/rails s -e production -p 3000', :chdir => REDMINE_DIR, :err => [LOG_FILE, 'a']
			# Redmine 3.0
			#@server_pid = Process.spawn 'D:\Documents\Developer\RailsInstaller\Ruby2.1.0\bin\rubyw bin/rails s -e production -p 3000', :chdir => REDMINE_DIR, :err => [LOG_FILE, 'a']
			
        end

        # This is the daemon's mainloop. In other words, whatever runs here
        # is the code that runs while your service is running. Note that the
        # loop is not implicit.
        #
        # You must setup a loop as I've done here with the 'while running?'
        # code, or setup your own loop. Otherwise your service will exit and
        # won't be especially useful.
        #
        # In this particular case, I've setup a loop to append a short message
        # and timestamp to the log file every 20 seconds. Remove the logging
        # when you are using this as a real service otherwise you logfile will
        # become large quickly.
		#
		# not sure what the (*args) means
        def service_main(*args)
						
			File.open(LOG_FILE, 'a'){ |f| f.puts "Service is running #{Time.now} with pid #{@server_pid}" }			
			msg = 'application started at: ' + Time.now.to_s
		
			File.open(LOG_FILE, 'a'){ |f|
				f.puts msg
				f.puts "Args: " + args.join(',')
			}

            # While the daemon is running
            while running?
                if state == RUNNING
                    sleep 20
					
					# write constantly to log file while running for diagnostics only
                    #msg = 'Service is running as of: ' + Time.now.to_s
                    #File.open(LOG_FILE, 'a'){ |f| f.puts msg }
					
                else # PAUSED or IDLE
                    sleep 0.5
                end
            end

            # We've left the loop, the daemon is about to exit.
			
            File.open(LOG_FILE, 'a'){ |f| f.puts "STATE: #{state}" }
            msg = 'service_main left at: ' + Time.now.to_s
            File.open(LOG_FILE, 'a'){ |f| f.puts msg }
			
        end

        # This event triggers when the service receives a signal to stop. I've
        # added an explicit "exit!" here to ensure that the Ruby interpreter exits
        # properly. I use 'exit!' instead of 'exit' because otherwise Ruby will
        # raise a SystemExitError, which I don't want.
        #
        def service_stop
		
			msg = 'Received stop signal at: ' + Time.now.to_s
			File.open(LOG_FILE, 'a'){ |f| f.puts msg }
						
			pid_file = 'tmp/pids/server.pid'
			
			File.open(LOG_FILE, 'a'){ |f| f.puts "Stopping server thread #{Time.now.to_s} with pid #{@server_pid}" }  
			system "taskkill /PID #{@server_pid} /T /F"				
			Process.waitall
			
			File.open(LOG_FILE, 'a'){ |f| f.puts "Service stopped #{Time.now.to_s}" }
			File.file?(pid_file) && File.delete(pid_file)		
			# exit! - what is this exit for? there was a reason, this seems to cause a bad exit with redmine but might be needed for other scripts
		end

        # This event triggers when the service receives a signal to pause. 
        #
        def service_pause
            msg = 'Received pause signal at: ' + Time.now.to_s
            File.open(LOG_FILE, 'a'){ |f| f.puts msg }
        end

        # This event triggers when the service receives a signal to resume
        # from a paused state.
        #
        def service_resume
            msg = 'Received resume signal at: ' + Time.now.to_s
            File.open(LOG_FILE, 'a'){ |f| f.puts msg }
        end
    end

    # Create an instance of the Daemon and put it into a loop. I borrowed the
    # method name 'mainloop' from Tk, btw.
    #
    RedmineDaemon.mainloop

#---------------------------------------------------------------------------
# Service Failure Logging
#--------------------------------------------------------------------------- 

rescue Exception => err
  File.open(LOG_FILE, 'a'){ |fh| fh.puts 'Daemon failure: ' + err + '\n'} # this one line  is from the 1 page script based on demo
  File.open(LOG_FILE,'a+'){ |f| f.puts " ***Daemon failure #{Time.now.to_s} exception=#{err.inspect}\n#{err.backtrace.join($/)}" }
  raise
end

 Notes

• the ctl file, once run has nothing to do with the daemon. It is just a configurator., the daemon is how indows interacts with ruby
• this script is written for Redmine 2.x but needs to be slightly amended to run Redmine 3.x . If you dont make the following change, the redmine service will fail to run and you will get the following error in the redmine-service.log file.
  

  script/rails no longer exists, please use bin/rails instead.

  To fix this you basically need to make the change as told in this error. You will see in the redmine-service.rb i have added Redmine 3.x versions, the lines you need to change from Redmine 2.x to 3.x are line 30 - line 36, the rest should be obvious.

Making Xampp a Dependency for the Redmine Service

If you are using xampp as the donour for the MySQL service you must make sure that this is running when the Redmine service is started otherwise it will fail and not start. To fix this you can make the xampp MySQL (and Apache if required) service as a dependency which means that when you start your redmine service it will start these dependant services first to make sur ethey are running.

Currently the scripts above are not enabled to call Xampp Apache and MySQL services as dependants, the code is there though. There are a couple of steps required to get this working if you want, otherwise you must manually start at least the MySQL service or already have it runnign before you start the redmine service

This feature requires 2 things to be done

1. Change Xampp Apache and MySQL Service names (Optional)
2. Edit the Redmine Service Script (we will be using 'My Complex Script')

NB:

• When the redmine service starts either the Xampp Apache or MySQL then you cannot stop and start these services through the xampp control panel, it just doesnt work and perhaps will get fixed in later versions. These reason is that windows knows that redmine started these services and it should be the redmine service that should stop them which it does when you stop and start it.
• If you go into windows and stop and start the Apache or MySQL service via services.msc windows is intelligent and knows the redmine service started these services so propmpt you that it will also stop the redmine service if you continue which it will close correctely.
• If the Apache and MySQL services are already started when you start the redmine service, they will not be classed as dependendant services and can be stoppped and started throught the xampp control panel
• I find it useful just to run only the  MySQL service as a dependant when playing with the httpd.conf file so i can easily stop and start the apache server in xampp.
• Redmine only require the requires the MySQL service to be running.

Change Xampp Service Names

If you want to run more than 1 Xampp installation, or even if you dont, i recommend that you should change the default service name for the Xampp Apache and MySQL services on you Developer Xampp instance. The reason for this is that if like me you use Xampp for developing websites on your Windows PC, the Xampp installationscheck by service name,  to see if the Apache and MySQL services are running. This means that if you setup your Developer site with the default service names, when you then open up another instance of Xampp it will think that it is running as a service even if you have not installed that instance as a service.

So by giving different names to these services we will be using for the redmine development xampp it can function independantly to any other xampp instances. This how most people would expect this to work. I also want this seperate installation of xampp because when i am poking around with code or messing databases for my regular web development i do not risk my development enviroment.

Changing the service names is optionals for those budding coders but i definately still recommend it for the reasons outlined above)

Instructions

To change the service names of Apache and MySQL is very easy and requires you to use the xampp control panel.

Apache Service

1. Open Xampp control panel as an administrator
2. Make sure the service is not running
3. If the service has already been installed, uninstall the service
4. click config (top right)
5. click 'Service and Port Settings'
6. click 'Apache' Tab
7. change the service name
   Apache2.4  ---->  Developer-Apache2.4
8. Install the service
9. Done

MySQL Service

1. Open Xampp control panel as an administrator
2. Make sure the service is not running
3. If the service has already been installed, uninstall the service
4. Click config (top right)
5. Click 'Service and Port Settings'
6. Click 'MySQL' tab
7. Change the service name
   mysql  ---->  Developer-MySQL
8. Install the service
9. Done

Edit the Redmine Service Script

This stage is also an easy one and involves editing the redmine_service_ctl.rb from 'My Complex Script' .

1. Open up a command prompt as an administrator
2. Navigate to you redmine root directory (should be D:\Documents\developer\RubyRoot\redmine )
3. If you have installed 'My Complex Script' you need to uninstalled it, run the following command
   
   ruby redmine_service_ctl.rb uninstall
   
   
4. If you have not installed 'My Complex Script' you need to create the 2 files redmine_service_ctl.rb and redmine_service.rb in your redmine root folder using the appropriate code from above
5. Open the file redmine_service_ctl.rb in a text editor
6. Look at line 88 - 89 and edit the file as follows:
   

   :dependencies     => nil,
   #:dependencies     => ['Developer-Apache2.4','Developer-MySQL'],

   You can see that there is a declaration of no dependencies. The line below it defines some depnedecies but is remmed out. Change the lines around so the service has dependencies. The new code should look like the code below, basically you have just changed the poistion of the Hash '#'

   #:dependencies     => nil,
   :dependencies     => ['Developer-Apache2.4','Developer-MySQL'],

    As you can see the service names match those i set earler but can be anything as long as they match the appropriate service.

7. Save the file
8. Install the redmine service via the command line now that it has dependencies configured. You should still have the command line open in your redmine root directory and running as an administrator
   
   ruby redmine_service_ctl.rb install
   
   
9. Done

Now start the redmine service and you will find it will start the Xampp apache and MySQL Services automatically.

Redmine as a Windows Service Final Thoughts

This is a robust way of having redmine running on your Windows PC and once configured you can practically forget about it and just use Redmine for what you wanted to use it for in the first place, software development. There are no more settings to do, you are ready to rock and roll.