come configurare un'app Rails (Redmine) per l'esecuzione come servizio su Windows?

https://stackoverflow.com/questions/877943

22-08-2019
|

Domanda

Sto utilizzando Redmine come gestore di ticket e vorrei configurarlo per l'esecuzione automatica all'avvio di Windows.

Come posso configurarlo per essere eseguito come servizio?

Ho appena posto la domanda per documentarla, spero che qualcuno possa trovarla utile...

Soluzione

1.utilizzando webrick:

rif: http://www.redmine.org/boards/1/topics/4123

Scaricare e installare il Resource Kit di Windows NT dahttp://www.microsoft.com/downloads/details.aspx?familyid=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en

Crea il servizio eseguendo questo comando:

path\INSTSRV.EXE your_service_name path\SRVANY.EXE

nel mio caso path È:

"C:\Program Files\Windows NT Resource Kit\INSTSRV.EXE" redmine_webrick "C:\Program Files\Windows NT Resource Kit\SRVANY.EXE"

potrebbe anche essere C:\Program Files\Windows Resource Kits\Tools\.

Esegui regedit (Start -> Esegui -> regedit)
- Aggiungi la seguente chiave di registro se non è già presente:
  
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services ome_servizio
- Fare clic con il tasto destro su questa chiave di registro e selezionare Nuovo -> Chiave.Nominalo Parameters.
- Aggiungi due valori a Parameters chiave.Fare clic con il tasto destro sulla chiave dei parametri, Nuovo -> Valore stringa.Nominalo Application.Ora creane un altro chiamato AppParameters.Assegna loro i seguenti valori:
  - Applicazione: PathToRuby.exe, per esempio. C:\ruby\bin\Ruby.exe
  - Parametri dell'app: C:\RUBYAPP\script\server -e production, Dove RUBYAPP è la directory che contiene il sito Web Redmine.
  Esempio: C:\redmine\script\server -p 2000 -e production (-p indica la porta che il webrick sarà in ascolto e -e l'ambiente utilizzato)

Ora puoi andare su Strumenti di amministrazione -> Servizi.Lì puoi avviare il tuo servizio (quello con nome your_service_name) e verificare se funziona correttamente o meno.Va notato che il servizio verrà contrassegnato come avviato prima che WEBrick termini la procedura di avvio.Dovresti concedergli circa 1 minuto prima di provare ad accedere al servizio per verificare che funzioni correttamente.

2.usando bastardo:

rif: http://mongrel.rubyforge.org/wikirif: http://mongrel.rubyforge.org/wiki/Win32

installare prima mongrel e mongrel_service gem

gem install mongrel

gem install mongrel_service

quindi creare il servizio

mongrel_rails service::install -N redmine_mongrel -c c:\redmine -p 3000 -e production

3.usando sottile:

Riferimenti:

Istruzioni:

Per prima cosa installa thin (dovrai installare la gemma rack, se non l'hai già fatto installato)
```
gem install rack     
gem install thin
```
Segui gli stessi passaggi indicati per webrick, ma aggiungi un altro valore denominato "AppDirectory".Ciò è necessario per evitare di utilizzare c: uby\bin hin.bat Se puntassi solo al file bat, non potrei interrompere il servizio.

In HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\redmine_thin\Parameters aggiungi le seguenti chiavi:

Applicazione:c: uby\bin uby.exe

Directory app:c: edmine

Parametri dell'app:c: uby\bin hin start -p 4000 -e produzione

------------------------------------------------------------------------------------------

Puoi controllare qualsiasi tuo servizio con i seguenti comandi:

inizio netto redmine_xxx

net stop redmine_xxx

sc config redmine_xxx start=auto

sc config redmine_xxx start= dipendenza automatica= MySql

sc elimina redmine_xxx

Altri suggerimenti

Per Rails applicazioni 3.0.x (testato su 3.0.10 e Windows 7)

demo_daemon_ctl.rb

############################################################################
# demo_daemon_ctl.rb
#
# This is a command line script for installing and/or running a small
# Ruby program as a service.  The service will simply write a small bit
# of text to a file every 20 seconds. It will also write some text to the
# 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 file in question is C:\test.log.  Feel free to delete it when finished.
#
# To run the service, you must install it first.
#
# Usage: ruby demo_daemon_ctl.rb <option>
#
# Note that you *must* pass this program an option
#
# Options:
#    install    - Installs the service.  The service name is "DemoSvc"
#                 and the display name is "Demo".
#    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
############################################################################
require 'win32/service'
require 'rbconfig'
include Win32
include Config

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

SERVICE_NAME = 'DemoSvc'
SERVICE_DISPLAYNAME = 'Demo'

# Quote the full path to deal with possible spaces in the path name.
ruby = File.join(CONFIG['bindir'], 'ruby').tr('/', '\\')
path = ' "' + File.dirname(File.expand_path($0)).tr('/', '\\')
path += '\demo_daemon.rb"'
cmd = ruby + path

# You must provide at least one argument.
raise ArgumentError, 'No argument provided' unless ARGV[0]

case ARGV[0].downcase
     when 'install'
            Service.new(
                 :service_name     => SERVICE_NAME,
                 :display_name     => SERVICE_DISPLAYNAME,
                 :description      => 'Sample Ruby service',
                 :binary_path_name => cmd
            )
            puts 'Service ' + SERVICE_NAME + ' installed'      
     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

demo_daemon.rb

APP_ROOT_CUSTOM = 'your app root dir'
LOG_FILE = APP_ROOT_CUSTOM + 'log/win32_daemon_test.log'
APP_PATH = File.expand_path( APP_ROOT_CUSTOM  + 'config/application', APP_ROOT_CUSTOM  + 'script/rails')

begin  
    require 'rubygems'
    require 'win32/daemon'
    include Win32
    require File.expand_path( APP_ROOT_CUSTOM  + 'config/boot', APP_ROOT_CUSTOM  + 'script/rails')
    require 'rails/commands/server'
    module ::Rails
        class Server
            def default_options
                super.merge({
                    :Port        => 3000,
                    :environment => (ENV['RAILS_ENV'] || "development").dup,
                    :daemonize   => false,
                    :debugger    => false,
                    :pid         => File.expand_path( APP_ROOT_CUSTOM + "tmp/pids/server.pid" ),
                    :config      => File.expand_path( APP_ROOT_CUSTOM + "config.ru" )
                })
            end
        end
    end

    class DemoDaemon < 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
        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 a file on your C: drive every 20 seconds. Be sure
        # to stop the service when you're done!
        #
        def service_main(*args)

            Rails::Server.new.tap { |server|
                require APP_PATH
                Dir.chdir( APP_ROOT_CUSTOM )
                server.start
            }

            msg = 'application started at: ' + Time.now.to_s

            File.open(LOG_FILE, 'a'){ |f|
                f.puts msg
                f.puts "Args: " + args.join(',')
            }

            # While we're in here the daemon is running.
            while running?
                if state == RUNNING
                    sleep 20 
                    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 }
            exit!
        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.
    #
    DemoDaemon.mainloop
rescue Exception => err
    File.open(LOG_FILE, 'a'){ |fh| fh.puts 'Daemon failure: ' + err }
    raise
end

posto entrambi i file nella stessa directory ed eseguire

ruby demo_daemon_ctl.rb install

http://www.firedaemon.com/

Qualche tempo fa, ho provato ad installare Redmine su Windows pure. Ma non ero in grado di farlo funzionare, probabilmente causa della mancanza di conoscenze Rails .

Poi ho scoperto Bitnami Redmine Stack . Hanno un programma di installazione di Windows, che installa Redmine con tutte le dipendenze necessarie, e semplicemente funziona .

Per le applicazioni Rails 4.0.x come suggerito da Bohdan, dobbiamo sostituire

config [ 'bindir'] con rbconfig :: config [ 'bindir']

Remmber a: gem install win32-service

gem install win32-service
goccia di seguito il codice Ruby in un percorso di file service.rb e aggiornamento REDMINE_DIR per adattare l'installazione Redmine
creare il servizio, ad esempio con sc create redmine binPath= "C:\Ruby23-x64\bin\rubyw -C E:\www\redmine-3.3.2\ service.rb" dove E:\www\redmine-3.3.2\ è il percorso della directory in cui si trova il file service.rb e C:\Ruby23-x64\bin\rubyw il percorso di installazione di Ruby

iniziare require 'Win32 / daemon' includere Win32

  class RedmineService < Daemon

    def service_init
      File.open(LOG_FILE, 'a'){ |f| f.puts "Initializing service #{Time.now}" } 

      #@server_pid = Process.spawn 'ruby script/rails s -e production', :chdir => REDMINE_DIR, :err => [LOG_FILE, 'a']
      # use full path
      @server_pid = Process.spawn 'C:\Ruby23-x64\bin\ruby E:\www\redmine-3.3.2\bin\rails s -e production -p 3000', :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}" }
      system "taskkill /PID #{@server_pid} /T /F" 
      Process.waitall
      File.open(LOG_FILE, 'a'){ |f| f.puts "Service stopped #{Time.now}" }
      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

Si noti che Process.spawn nel service.rb utilizzare il percorso completo.

Spero che questo vi aiuterà a chiunque. Ho definito il servizio di Windows che avvia il redmine con il server sottile.

http://nssm.cc/usage per la creazione di un servizio di Windows. Impostare il percorso per ruby.exe, directory di lavoro del vostro Redmine e definire i parametri di partenza:

Path: C:\RailsInstaller\Ruby2.3.3\bin\ruby.exe
Startup directory: C:\Program Files\redmine-3.4.6
Arguments: C:\RailsInstaller\Ruby2.3.3\bin\thin start -e production -p 3000

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow