Wie konfigurieren Sie eine Rails -App (Redmine) so, dass sie als Service unter Windows ausgeführt werden?

https://stackoverflow.com/questions/877943

22-08-2019
|

Frage

Ich benutze Redmine als Ticket -Manager, und ich möchte es so konfigurieren, dass es beim Start von Windows automatisch ausgeführt wird.

Wie kann ich es so konfigurieren, dass es als Dienst ausgeführt wird?

Ich habe gerade die Frage gestellt, um sie zu dokumentieren, ich hoffe, jemand kann sie nützlich finden ...

Lösung

1. Verwenden von Webebrick:

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

Laden Sie das Windows NT -Ressourcen -Kit aus und installieren Sie sie vonhttp://www.microsoft.com/downloads/details.aspx?familyid=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en

Erstellen Sie den Dienst, indem Sie diesen Befehl ausführen:

path\INSTSRV.EXE your_service_name path\SRVANY.EXE

in meinem Fall path ist:

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

könnte auch sein C:\Program Files\Windows Resource Kits\Tools\.

Run regeedit (Start -> Run -> regeldit)
- Fügen Sie den folgenden Registrierungsschlüssel hinzu, wenn es noch nicht vorhanden ist:
  
  HKEY_LOCAL_MACHINE SYSTEM CurrentControlSet Services Your_Service_Name
- Klicken Sie mit der rechten Maustaste auf diesen Registrierungsschlüssel und wählen Sie neu -> Schlüssel. Nennen Sie es Parameters.
- Fügen Sie dem zwei Werte hinzu Parameters Schlüssel. Klicken Sie mit der rechten Maustaste auf die Parameterschlüssel, neu -> String -Wert. Nennen Sie es Application. Erstellen Sie nun einen anderen namens namens AppParameters. Geben Sie ihnen die folgenden Werte an:
  - Anwendung: PathToRuby.exe, z.B. C:\ruby\bin\Ruby.exe
  - AppParameters: C:\RUBYAPP\script\server -e production, wo RUBYAPP ist das Verzeichnis, das die Redmine -Website enthält.
  Beispiel: C:\redmine\script\server -p 2000 -e production (-P gibt an, dass der Port Webrick die verwendete Umgebung hört und -e).

Jetzt können Sie zu Verwaltungswerkzeugen -> Dienste gehen. Dort können Sie Ihren Service starten (der mit Namen your_service_name) und testen Sie, ob es ordnungsgemäß funktioniert oder nicht. Es ist zu beachten, dass der Dienst als gestartet vor Webrick markiert wird, der seinen Boot -Verfahren beendet hat. Sie sollten es ungefähr 1 Minuten geben, bevor Sie versuchen, den Dienst zu treffen, um zu überprüfen, ob er richtig funktioniert.

2. Mit Mischling:

Ref: http://mongrel.rubyforge.org/wikiRef: http://mongrel.rubyforge.org/wiki/win32

Installieren Sie zuerst Mischglasse und Mischling.

gem install mongrel

gem install mongrel_service

Erstellen Sie dann den Dienst

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

3. Verwenden Sie dünn:

Verweise:

Anweisungen:

Installieren Sie zuerst dünn (Sie müssen Rack -Edelstein installieren, falls dies nicht bereits installiert ist)
```
gem install rack     
gem install thin
```
Befolgen Sie die gleichen Schritte für Webrick, fügen Sie jedoch einen weiteren Wert mit dem Namen "AppDirectory" hinzu. Dies ist erforderlich, um die Verwendung von C: Ruby bin din.bat zu vermeiden. Wenn ich nur auf die Fledermausdatei hingewiesen habe, konnte ich den Dienst nicht stoppen.

Im HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\redmine_thin\Parameters Fügen Sie die folgenden Schlüssel hinzu:

Anwendung: C: Ruby bin ruby.exe

AppDirectory: C: Redmine

AppParameters: C: Ruby bin Thin Start -p 4000 -e Produktion

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

Sie können jeden Ihrer Dienst mit den folgenden Befehlen steuern:

net start redmine_xxx

Net Stop Redmine_xxx

SC -Konfiguration Redmine_xxx start = auto

SC -Konfiguration Redmine_xxx start = auto abhängig = mysql

SC Delete Redmine_xxx

Andere Tipps

Für Rails 3.0.x -Anwendungen (getestet auf 3.0.10 & 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

Platzieren Sie beide Dateien in derselben Dir und laufen Sie aus

ruby demo_daemon_ctl.rb install

verwenden http://www.firedaemon.com/

Vor einiger Zeit habe ich versucht, Redmine auch unter Windows zu installieren. Aber ich konnte es wahrscheinlich nicht zum Laufen bringen Wegen mangelnder Kenntnis.

Dann entdeckte ich Bitnami Redmine Stack. Sie haben einen Windows -Installationsprogramm, der Redmine mit allen benötigten Abhängigkeiten installiert. Und es funktioniert einfach.

Für Rails 4.0.x -Anwendungen, wie von Bohdan vorgeschlagen, müssen wir ersetzen

Config ['bindir'] mit rbconfig :: config ['bindir'

REMMBER ZU: GEM Installieren Sie Win32-Service

gem install win32-service
Drop unter dem Ruby -Code in einem Service.RB -Datei und aktualisieren Sie Redmine_dir Pfad, um Ihre Redmine -Installation anzupassen
Erstellen Sie den Dienst beispielsweise mit sc create redmine binPath= "C:\Ruby23-x64\bin\rubyw -C E:\www\redmine-3.3.2\ service.rb" wo E:\www\redmine-3.3.2\ ist der Weg des Verzeichnisses, in dem sich die Datei Service.rb befindet und C:\Ruby23-x64\bin\rubyw Ihr Rubin -Installationspfad

Starten Sie benötigen 'Win32/Daemon' inklusive 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

Beachten Sie diesen Prozess.Spawn im Service.RB Verwenden Sie den vollständigen Pfad.

Ich hoffe, das wird jedem helfen. Ich habe den Windows -Dienst definiert, der die Redmine mit dem dünnen Server startet.

Verwenden http://nssm.cc/usage Für die Erstellung von Windows Service. Stellen Sie den Pfad auf Ruby.exe, das Arbeitsverzeichnis Ihres Redmine, und definieren Sie die Startparameter:

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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow