DB-Verbindungen über Objekte mit Klassenmethoden in Ruby teilen?

Question

Ich schreibe ein Ruby-Skript, das als Postfix-SMTP-Zugriffsrichtlinien-Delegierung verwendet wird. Das Skript muss auf eine Tokyo Tyrant-Datenbank zugreifen. Ich verwende EventMachine, um Netzwerkverbindungen zu verwalten. EventMachine benötigt eine EventMachine :: Connection-Klasse, die bei jedem Erstellen einer neuen Verbindung von der Verarbeitungsschleife der EventMachine instanziiert wird. So wird für jede Verbindung eine Klasse instanziiert und zerstört.

Ich erstelle eine Verbindung zu Tokyo Tyrant von der post_init der EventMachine :: Connection (dh direkt nach dem Verbindungsaufbau) und zerreiße es nach dem Verbindungsabbau.

Meine Frage ist, ob dies der richtige Weg ist, um eine Verbindung zu db herzustellen? zB eine Verbindung herstellen, jeden Moment, wenn ich es brauche, und es abreißen, nachdem ich fertig bin? Wäre es nicht besser, einmal mit der DB zu verbinden (wenn das Programm gestartet wird), reißen Sie es während des Programms herunter? Wenn das so ist, wie soll ich das programmieren?

Mein Code ist:

require 'rubygems' 
require 'eventmachine' 
require 'rufus/tokyo/tyrant' 

class LineCounter < EM::Connection 
    ActionAllow = "action=dunno\n\n" 

    def post_init 
    puts "Received a new connection" 
    @tokyo = Rufus::Tokyo::Tyrant.new('server', 1978) 
    @data_received = "" 
    end 

    def receive_data data 
    @data_received << data 
    @data_received.lines do |line| 
     key = line.split('=')[0] 
     value = line.split('=')[1] 
     @reverse_client_name = value.strip() if key == 'reverse_client_name' 
     @client_address = value.strip() if key == 'client_address' 
     @tokyo[@client_address] = @reverse_client_name 
    end 
    puts @client_address, @reverse_client_name 
    send_data ActionAllow 
    end 

    def unbind 
    @tokyo.close 
    end 
end 

EventMachine::run { 
    host,port = "127.0.0.1", 9997 
    EventMachine::start_server host, port, LineCounter 
    puts "Now accepting connections on address #{host}, port #{port}..." 
    EventMachine::add_periodic_timer(10) { $stderr.write "*" } 
} 

mit Grüßen,

raj

Answer 1

Surprising auf diese Frage keine Antwort gibt.

Was Sie wahrscheinlich brauchen, ist ein Verbindungspool, wo Sie Verbindungen abrufen, verwenden und zurückgeben können, wie sie benötigt werden.

class ConnectionPool 
    def initialize(&block) 
    @pool = [ ] 
    @generator = block 
    end 

    def fetch 
    @pool.shift or @generator and @generator.call 
    end 

    def release(handle) 
    @pool.push(handle) 
    end 

    def use 
    if (block_given?) 
     handle = fetch 

     yield(handle) 

     release(handle) 
    end 
    end 
end 

# Declare a pool with an appropriate connection generator 
tokyo_pool = ConnectionPool.new do 
    Rufus::Tokyo::Tyrant.new('server', 1978) 
end 

# Fetch/Release cycle 
tokyo = tokyo_pool.fetch 
tokyo[@client_address] = @reverse_client_name 
tokyo_pool.release(tokyo) 

# Simple block-method for use 
tokyo_pool.use do |tokyo| 
    tokyo[@client_address] = @reverse_client_name 
end