La condivisione connessioni DB attraverso oggetti utilizzando metodi di classe in Ruby?

Question

Sto scrivendo uno script Ruby da utilizzare come Postfix SMTP delegazione politica di accesso. Lo script ha bisogno di accedere a un database di Tokyo Tiranno. Sto usando EventMachine di prendersi cura di connessioni di rete. EventMachine bisogno di una classe EventMachine :: Connection che viene istanziato dal ciclo di elaborazione del EventMachine ogni volta che si crea una nuova connessione. quindi per ogni connessione una classe viene istanziata e distrutto.

sto creando una connessione a Tokyo Tyrant dal post_init del EventMachine :: Connection (vale a dire subito dopo la connessione è messa a punto) e lo strappo verso il basso dopo la connessione viene terminata.

La mia domanda è se questo è il modo corretto per la connessione al db? cioè facendo una connessione ogni yime ho bisogno e demolirlo dopo che io sono finito? Non sarebbe meglio per la connessione al DB, una volta (quando viene avviato il programma) abbatterlo durante l'arresto del programma? Se le cose stanno così come dovrei codice che?

Il mio codice è:

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 "*" }
}

per quanto riguarda,

raj

Answer 1

Sorprendente non ci sono risposte a questa domanda.

Quello che probabilmente serve è un pool di connessione in cui è possibile recuperare, l'uso, e restituire i collegamenti come sono tenuti.

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