Le partage de connexions DB à travers des objets en utilisant des méthodes de classe en Ruby?

Question

Je suis en train d'écrire un script Ruby à utiliser comme une délégation de la politique d'accès SMTP Postfix. Le script a besoin d'accéder à une base de données de Tokyo Tyrant. J'utilise eventmachine pour prendre soin des connexions réseau. Eventmachine a besoin d'un eventmachine :: classe de connexion qui est instancié par la boucle de traitement de eventmachine chaque fois qu'une nouvelle connexion est créée. donc pour chaque connexion une classe est instancié et détruit.

Je suis en train de créer une connexion à Tokyo Tyrant de la post_init du eventmachine :: connexion (ie juste après connexion est configuré) et déchirer vers le bas après est mis fin à la connexion.

Ma question est de savoir si cela est la bonne façon de se connecter à db? à-dire faire une connexion à chaque yime je besoin et déchirer vers le bas après que je suis fini? Ce ne serait pas mieux de se connecter à la DB une fois (lorsque le programme est lancé) déchirer vers le bas lors de l'arrêt du programme? Si tel est le comment dois-je le code qui?

Mon code est:

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

en ce qui concerne,

raj

Answer 1

Surprenant il n'y a pas de réponse à cette question.

Qu'est-ce que vous avez probablement besoin est une piscine de connexion où vous pouvez chercher, utiliser, et de retour comme ils sont nécessaires.

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