Detener con seguridad em-websocket en rieles en thin

Question

Tengo una aplicación de rieles Estoy ejecutando en un servidor delgado para utilizar el bucle de ejecución de EventMachine. El problema es que me gustaría poder incluir em-websocket para procesar información proveniente de un ws y detener e iniciar el websocket sin detener el ciclo de ejecución de EM. Así es como estoy empezando el websocket.

EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws| 
    ws.onopen { } 
    ws.onclose { } 
    ws.onmessage { |msg| } 
end 

El problema está en el código de inicio/detención. De docs em-WebSocket

#Start WebSocket 
def self.start(options, &blk) 
    EM.epoll 
    EM.run do 

    trap("TERM") { stop } 
    trap("INT") { stop } 

    EventMachine::start_server(options[:host], options[:port], 
     EventMachine::WebSocket::Connection, options) do |c| 
     blk.call(c) 
    end 
    end 
end 


#Stop WebSocket 
def self.stop 
    puts "Terminating WebSocket Server" 
    EventMachine.stop 
end 

El problema es que el código em-WebSocket interna no hace un seguimiento de la firma procedente de EM: start_server para poder llamar EventMachine :: stop_server (firma) para apagarlo. ¿Hay alguna manera de que pueda anular estas funciones sin modificar em-websocket para que pueda iniciar/detener estos websockets de forma segura? Me gustaría si funcionara más como el servidor estándar de Eventmachine.

Answer 1

Me parece que no necesita usar EM :: Websocket.start(). En su lugar, escriba su propio código de inicio/detención, luego puede administrar la firma usted mismo.

# start a ws server and return the signature 
# caller is responsible for +trap+ing to stop it later using said signature. 
def start_ws_server(options, &blk) 
    return EventMachine::start_server(options[:host], options[:port], 
    EventMachine::WebSocket::Connection, options) do |c| 
    blk.call(c) 
    end 
end 

# stop a previously started ws server 
def stop_ws_server(signature) 
    EventMachine::stop_server signature 
end 

Ahora puede iniciar y capturar la firma y detenerla más tarde utilizándola. No hay código de trampa en el método de inicio ya que en ese punto la firma es desconocida. Como está capturando la sig fuera del método, también puede atrapar afuera y usar la sig almacenada allí.