miyazakiresistance 0.1.5 → 0.1.6

data/Manifest.txt

@@ -3,9 +3,11 @@ Manifest.txt
 README.rdoc
 Rakefile
 lib/miyazakiresistance.rb
+lib/miyazaki_resistance.rb
 lib/miyazaki_resistance/base.rb
 lib/miyazaki_resistance/error.rb
 lib/miyazaki_resistance/miyazaki_logger.rb
-lib/miyazaki_resistance/tokyo_connection.rb
-lib/miyazaki_resistance/enhance.rb
+lib/miyazaki_resistance/connection.rb
+lib/miyazaki_resistance/column.rb
+lib/miyazaki_resistance/operation.rb
 initializers/rdb.rb

data/README.rdoc

@@ -12,13 +12,13 @@ MiyazakiResistance support Dual Master(Active/Standby). If Active server down, S
 
   require 'miyazakiresistance'
   class Example < MiyazakiResistance::Base
-    set_server "localhost", 1975, :write
-    set_server "slave", 1975, :standby
-    set_timeout 1
-    set_column :name, :string
-    set_column :age, :integer
-    set_column :birthday, :date
-    set_column :created_at, :datetime
+    server :localhost, 1975, :write
+    server :slave_host, 1975, :standby
+    timeout 1
+    column :name, :string
+    column :age, :number
+    column :birthday, :date
+    column :created_at, :datetime
   end
 
   work = Example.new
@@ -48,11 +48,11 @@ MiyazakiResistance support Dual Master(Active/Standby). If Active server down, S
   require 'miyazakiresistance'
   class Example < MiyazakiResistance::Base
     server_config Rails.env, "log/miyazakiresistance.yml"
-    set_timeout 60
-    set_column :name, :string
-    set_column :age, :integer
-    set_column :birthday, :date
-    set_column :created_at, :datetime
+    timeout 60
+    column :name, :string
+    column :age, :integer
+    column :birthday, :date
+    column :created_at, :datetime
   end
 
   'in log/miyazakiresistance.log'

data/initializers/rdb.rb

@@ -1,3 +1,5 @@
+require 'tokyotyrant'
+
 module TokyoTyrant
   class RDB
     attr_accessor :host, :port, :open_flag

data/lib/miyazaki_resistance.rb

@@ -0,0 +1,17 @@
+Dir.glob("#{File.join(File.dirname(__FILE__), "../initializers")}/*.rb").each{|path| require path}
+
+module MiyazakiResistance
+  VERSION = [0, 1, 6]
+
+  def self.version
+    VERSION * "."
+  end
+end
+MR = MiyazakiResistance
+
+require "miyazaki_resistance/column"
+require "miyazaki_resistance/operation"
+require "miyazaki_resistance/connection"
+require "miyazaki_resistance/base"
+require "miyazaki_resistance/miyazaki_logger"
+require "miyazaki_resistance/error"

data/lib/miyazaki_resistance/base.rb

@@ -3,30 +3,8 @@ module MiyazakiResistance
     attr_accessor :id
 
     def initialize(args = nil)
-      args ||= {}
       self.id = nil
-      args.each do |key, value|
-        if key.is_a?(String) && key.empty?
-          key = :id
-          value = value.to_i
-        else
-          case self.class.all_columns[key.to_s]
-          when :integer
-            value = value.to_i
-          when :string
-            value = value.to_s
-          when :datetime
-            value = Time.at(value.to_i) unless value.is_a?(Time)
-          when :date
-            unless value.is_a?(Date)
-              time = Time.at(value.to_i)
-              value = Date.new(time.year, time.month, time.day)
-            end
-          end
-        end
-        
-        self.__send__("#{key}=", value)
-      end
+      set_args(args || {})      
     end
 
     def save
@@ -55,16 +33,6 @@ module MiyazakiResistance
       retry
     end
 
-    def attributes
-      hash = {}
-      self.class.all_columns.keys.each{|key| hash.update(key => self.__send__(key))}
-      hash
-    end
-
-    def attributes=(args)
-      args.each {|key, value| self.__send__("#{key}=", value)}
-    end
-
     def new_record?
       self.id.nil?
     end
@@ -144,37 +112,32 @@ module MiyazakiResistance
       def create(args)
         self.new(args).save
       end
-    end
 
-    private
+      def method_missing(name, *arguments, &block)
+        if match = finder_attribute_names(name)
+          finder = match[:finder]
+          conditions = match[:cols].map{|col| "#{col} = ?"}.join(" ")
 
-    def raw_attributes
-      hash = {}
-      self.class.all_columns.each do |col, type|
-        value = self.__send__(col)
-        value = self.class.plastic_data(value, type)
-        hash.update(col.to_s => value)
-      end
-      hash
-    end
+          self.class_eval %Q|
+            def self.#{name}(*args)
+              options = args.last.is_a?(::Hash) ? pop : {}
+              options.update(:conditions => ["#{conditions}", args].flatten)
+              self.find(:#{finder}, options)
+            end
+          |
 
-    def time_column_check
-      time_columns = ["updated"]
-      time_columns << "created" if new_record?
-      time_columns.each do |col|
-        %w|at on|.each do |type|
-          if self.class.all_columns.keys.include?("#{col}_#{type}")
-            now = Time.now
-            now = Date.new(now.year, now.month, now.day) if type == "on"
-            self.__send__("#{col}_#{type}=", now) if self.__send__("#{col}_#{type}").nil? || col == "updated"
-          end
+          __send__(name, *arguments)
+        else
+          super
         end
       end
     end
 
+    private
+
     def self.type_upcase(type)
       case type
-      when :integer, :datetime, :date
+      when :number, :datetime, :date
         "NUM"
       when :string
         "STR"
@@ -205,7 +168,7 @@ module MiyazakiResistance
       if order
         target, order_type = order.split
         if target == "id" || self.all_columns.keys.include?(target)
-          type = (target == "id" ? :integer : self.all_columns[target])
+          type = (target == "id" ? :number : self.all_columns[target])
           target = "" if target == "id"
           order_type ||= "asc"
           eval(%Q|query.setorder(target, TokyoTyrant::RDBQRY::QO#{type_upcase(type)}#{order_type.upcase})|)
@@ -230,11 +193,11 @@ module MiyazakiResistance
             type = self.all_columns[item]
           elsif item == "id"
             col = ""
-            type = :integer
+            type = :number
           elsif OPERATIONS.keys.include?(item)
             raise QueryError if col.nil? || type.nil?
             work = type
-            work = :integer if DATE_TYPE.include?(work)
+            work = :number if DATE_TYPE.include?(work)
             ope = OPERATIONS[item][work]
             if not_flag
               raise QueryError unless NOT_OPERATIONS.include?(item)
@@ -264,16 +227,17 @@ module MiyazakiResistance
       query
     end
 
-    def self.plastic_data(value, type)
-      ret = case type
-      when :datetime
-        value.to_i
-      when :date
-        Time.local(value.year, value.month, value.day).to_i
-      else
-        value
+    def self.finder_attribute_names(name)
+      ret = {:finder => :first, :cols => nil}
+      if name.to_s =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+        ret[:finder] = :all if $1 == "all_by"
+        if cols = $2
+          cols = cols.split("_and_")
+          all_cols = self.all_columns.keys
+          ret[:cols] = cols  if cols.all?{|col| all_cols.include?(col)}
+        end
       end
-      ret.to_s
+      (ret[:cols].nil? || ret[:cols].empty?) ? nil : ret
     end
   end
 end

data/lib/miyazaki_resistance/column.rb

@@ -0,0 +1,89 @@
+module MiyazakiResistance
+  class Base
+    class << self
+      attr_accessor :all_columns
+
+      def column(name, type, index = :no_index)
+        self.all_columns ||= {}
+        name = name.to_s
+        self.__send__(:attr_accessor, name)
+        type = :number if type.to_s == "integer"
+        self.all_columns.update(name => type)
+      end
+      alias :set_column :column
+
+      def plastic_data(value, type)
+        ret = case type
+        when :datetime
+          value ? value.to_i : nil
+        when :date
+          value ? Time.local(value.year, value.month, value.day).to_i : nil
+        else
+          value
+        end
+        ret.to_s
+      end
+    end
+
+    def attributes
+      self.class.all_columns.keys.inject({}) {|hash, key| hash.merge(key => self.__send__(key))}
+    end
+
+    def attributes=(args)
+      args.each {|key, value| self.__send__("#{key}=", value)}
+    end
+
+    private
+
+    def raw_attributes
+      hash = {}
+      self.class.all_columns.each do |col, type|
+        next unless value = self.__send__(col)
+        value = self.class.plastic_data(value, type)
+        hash.update(col.to_s => value)
+      end
+      hash
+    end
+
+    def time_column_check
+      time_columns = ["updated"]
+      time_columns << "created" if new_record?
+      time_columns.each do |col|
+        %w|at on|.each do |type|
+          if self.class.all_columns.keys.include?("#{col}_#{type}")
+            now = Time.now
+            now = Date.new(now.year, now.month, now.day) if type == "on"
+            self.__send__("#{col}_#{type}=", now) if self.__send__("#{col}_#{type}").nil? || col == "updated"
+          end
+        end
+      end
+    end
+
+    def set_args(args)
+      args.each do |key, value|
+        if key.is_a?(String) && key.empty?
+          key, = :id
+          value = value.to_i if value
+        else
+          case self.class.all_columns[key.to_s]
+          when :number
+            value = (value =~ /\./) ? value.to_f : value.to_i if value
+          when :string
+            value = value.to_s if value
+          when :datetime
+            value = Time.at(value.to_i) if value && !value.is_a?(Time)
+          when :date
+            if value && !value.is_a?(Date)
+              time = Time.at(value.to_i)
+              value = Date.new(time.year, time.month, time.day)
+            end
+          else
+            next
+          end
+        end
+        
+        self.__send__("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/miyazaki_resistance/connection.rb

@@ -0,0 +1,163 @@
+require 'tokyotyrant'
+require 'timeout'
+require 'yaml'
+
+module MiyazakiResistance
+  class Base
+    @@connection_manager = {}
+
+    class <<self
+      %w|server_config server timeout remove_pool|.each do |method|
+        class_eval %Q|
+          def #{method}(*args)
+            connection_or_create.#{method}(*args)
+          end
+        |
+      end
+      alias :set_server :server
+      alias :set_timeout :timeout
+
+      %w|read write|.each do |role|
+        class_eval %Q|
+          def #{role}_connection
+            con = connection
+            con ? con.#{role}_connection : nil
+          end
+        |
+      end
+
+      def connection
+        @@connection_manager[self]
+      end
+
+      def connection_or_create
+        @@connection_manager[self] ||= MR::Connection.new
+      end
+
+      def kaeru_timeout(&block)
+        con = connection
+        con.kaeru_timeout(&block)
+      end
+    end
+
+    def read_connection
+      self.class.read_connection
+    end
+
+    def write_connection
+      self.class.write_connection
+    end
+
+    def remove_pool(con)
+      self.class.remove_pool(con)
+    end
+
+    def kaeru_timeout(&block)
+      self.class.kaeru_timeout(&block)
+    end
+  end
+
+  class Connection
+    DEFAULT = {:timeout => 5, :config => "miyazakiresistance.yml", :port => 1978, :role => :readonly}
+
+    attr_accessor :connection_pool
+    attr_accessor :timeout_time
+
+    def server_config(env, file = DEFAULT[:config])
+      conf = YAML.load_file(file)
+      if config = conf[env.to_s]
+        config["set_server"].each do |work|
+          server(work["server"], work["port"], work["role"])
+        end
+      else
+        MR::MiyazakiLogger.fatal "specified environment(#{env}) is not found in conig file(#{file})"
+      end
+    rescue Errno::ENOENT => e
+      MR::MiyazakiLogger.fatal "config file is not found : #{file}"
+    end
+
+    def server(host, port = DEFAULT[:port], role = DEFAULT[:role])
+      self.connection_pool ||= {:read => [], :write => nil, :standby => nil}
+      rdb = TokyoTyrant::RDBTBL.new
+      MR::MiyazakiLogger.info "set server host : #{host} port : #{port} role : #{role}"
+
+      rdb.set_server(host.to_s, port)
+
+      if role.to_sym == :standby
+        self.connection_pool[:standby] = rdb
+      else
+        self.connection_pool[:read] << rdb
+        self.connection_pool[:write] = rdb if role.to_sym == :write
+      end
+    end
+
+    def timeout(seconds)
+      self.timeout_time = seconds.to_i
+    end
+
+    def connection(con)
+      unless con.open?
+        unless con.open
+          MR::MiyazakiLogger.fatal "TokyoTyrantConnectError host : #{con.host} port : #{con.port}"
+          raise MiyazakiResistance::TokyoTyrantConnectError
+        end
+      end
+      con
+    end
+
+    def read_connection
+      check_pool
+      connection(self.connection_pool[:read].sort_by{rand}.first)
+    end
+
+    def write_connection
+      connection(self.connection_pool[:write])
+    end
+
+    def remove_pool(rdb)
+      self.connection_pool[:read].delete_if{|pool| pool == rdb}
+
+      host, port = rdb.host, rdb.port
+      new_rdb = TokyoTyrant::RDBTBL.new
+      if new_rdb.open(host, port)
+        self.connection_pool[:read] << new_rdb
+        self.connection_pool[:write] = new_rdb if rdb == self.connection_pool[:write]
+      else
+        MR::MiyazakiLogger.fatal "remove pool : host #{host} port : #{port}"
+        fail_over if rdb == self.connection_pool[:write]
+      end
+      rdb.close
+    end
+
+    def kaeru_timeout(&block)
+      ret = nil
+      thread = Thread.new{ret = yield}
+      raise TimeoutError, "tokyo tyrant server response error" unless thread.join(self.timeout_time || DEFAULT[:timeout])
+      ret
+    end
+
+    private
+
+    def all_connections
+      [self.connection_pool[:read], self.connection_pool[:write], self.connection_pool[:standby]].flatten.compact.uniq
+    end
+
+    def check_pool
+      return if self.connection_pool[:read] && !self.connection_pool[:read].empty?
+      MR::MiyazakiLogger.fatal "AllTimeoutORConnectionPoolEmpty"
+      raise MiyazakiResistance::AllTimeoutORConnectionPoolEmpty
+    end
+
+    def fail_over
+      unless self.connection_pool[:standby]
+        MR::MiyazakiLogger.fatal "MasterDropError"
+        raise MiyazakiResistance::MasterDropError
+      end
+
+      MR::MiyazakiLogger.fatal "master server failover"
+      self.connection_pool[:write] = self.connection_pool[:standby]
+      self.connection_pool[:read] << self.connection_pool[:standby]
+      self.connection_pool[:standby] = nil
+    end
+  end
+end

data/lib/miyazaki_resistance/miyazaki_logger.rb

@@ -1,25 +1,25 @@
+require 'logger'
+
 module MiyazakiResistance
-  module MiyazakiLogger
-    def self.included(base)
-      base.class_eval do
-        @@logger = nil
-      end
-      base.extend ClassMethods
-      base.__send__(:include, InstanceMethods)
+  class MiyazakiLogger
+    @@logger = nil
+
+    def initialize(file)
+      @file = file
     end
 
-    module ClassMethods
+    class << self
       def logger
-        class_variable_get("@@logger") || (logger = Logger.new(default_log_file_path))
+        @@logger || (logger = Logger.new(default_log_file_path))
       end
 
       def logger=(target)
-        class_variable_set("@@logger", target)
+        @@logger = target
       end
 
       %w|fatal error warn info debug|.each do|level|
         self.class_eval %Q|
-          def logger_#{level}(str)
+          def #{level}(str)
             put_log(str, "#{level}")
           end
         |
@@ -39,19 +39,5 @@ module MiyazakiResistance
         File.directory?("log") ? "log/miyazakiresistance.log" : "miyazakiresistance.log"
       end
     end
-
-    module InstanceMethods
-      def logger
-        self.class.logger
-      end
-
-      %w|fatal error warn info debug|.each do|level|
-        self.class_eval %Q|
-          def logger_#{level}(str)
-            self.class.logger_#{level}g(str)
-          end
-        |
-      end
-    end
   end
 end

data/lib/miyazaki_resistance/operation.rb

@@ -0,0 +1,24 @@
+module MiyazakiResistance
+  class Base
+    OPERATIONS = {
+      "=" => {:string => TokyoTyrant::RDBQRY::QCSTREQ, :number => TokyoTyrant::RDBQRY::QCNUMEQ},
+      "!=" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :number => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCNUMEQ},
+      "<>" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :number => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCNUMEQ},
+      "include" => {:string => TokyoTyrant::RDBQRY::QCSTRINC},
+      "begin" => {:string => TokyoTyrant::RDBQRY::QCSTRBW},
+      "end" => {:string => TokyoTyrant::RDBQRY::QCSTREW},
+      "allinclude" => {:string => TokyoTyrant::RDBQRY::QCSTRAND},
+      "anyinclude" => {:string => TokyoTyrant::RDBQRY::QCSTROR},
+      "in" => {:string => TokyoTyrant::RDBQRY::QCSTROREQ, :number => TokyoTyrant::RDBQRY::QCNUMOREQ},
+      "=~" => {:string => TokyoTyrant::RDBQRY::QCSTRRX},
+      "!~" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTRRX},
+      ">" => {:number => TokyoTyrant::RDBQRY::QCNUMGT},
+      ">=" => {:number => TokyoTyrant::RDBQRY::QCNUMGE},
+      "<" => {:number => TokyoTyrant::RDBQRY::QCNUMLT},
+      "<=" => {:number => TokyoTyrant::RDBQRY::QCNUMLE},
+      "between" => {:number => TokyoTyrant::RDBQRY::QCNUMBT}
+    }
+    NOT_OPERATIONS = %w|include begin end allinclude anyinclude in between|
+    DATE_TYPE = [:datetime, :date]
+  end
+end

data/lib/miyazakiresistance.rb

@@ -1,40 +1 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require 'logger'
-require 'timeout'
-require 'tokyotyrant'
-
-Dir.glob("#{File.join(File.dirname(__FILE__), "../initializers")}/*.rb").each{|path| require path}
-Dir.glob("#{File.join(File.dirname(__FILE__), "miyazaki_resistance")}/*.rb").each{|path| require path}
-
-module MiyazakiResistance
-  VERSION = '0.1.5'
-end
-
-MiyazakiResistance::Base.class_eval do
-  include MiyazakiResistance::TokyoConnection
-  include MiyazakiResistance::Enhance
-  include MiyazakiResistance::MiyazakiLogger
-
-  OPERATIONS = {
-    "=" => {:string => TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNUMEQ},
-    "!=" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCNUMEQ},
-    "<>" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCNUMEQ},
-    "include" => {:string => TokyoTyrant::RDBQRY::QCSTRINC},
-    "begin" => {:string => TokyoTyrant::RDBQRY::QCSTRBW},
-    "end" => {:string => TokyoTyrant::RDBQRY::QCSTREW},
-    "allinclude" => {:string => TokyoTyrant::RDBQRY::QCSTRAND},
-    "anyinclude" => {:string => TokyoTyrant::RDBQRY::QCSTROR},
-    "in" => {:string => TokyoTyrant::RDBQRY::QCSTROREQ, :integer => TokyoTyrant::RDBQRY::QCNUMOREQ},
-    "=~" => {:string => TokyoTyrant::RDBQRY::QCSTRRX},
-    "!~" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTRRX},
-    ">" => {:integer => TokyoTyrant::RDBQRY::QCNUMGT},
-    ">=" => {:integer => TokyoTyrant::RDBQRY::QCNUMGE},
-    "<" => {:integer => TokyoTyrant::RDBQRY::QCNUMLT},
-    "<=" => {:integer => TokyoTyrant::RDBQRY::QCNUMLE},
-    "between" => {:integer => TokyoTyrant::RDBQRY::QCNUMBT}
-  }
-  NOT_OPERATIONS = %w|include begin end allinclude anyinclude in between|
-  DATE_TYPE = [:datetime, :date]
-end
+require 'miyazaki_resistance'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: miyazakiresistance
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - Tsukasa OISHI
@@ -49,11 +49,13 @@ files:
 - README.rdoc
 - Rakefile
 - lib/miyazakiresistance.rb
+- lib/miyazaki_resistance.rb
 - lib/miyazaki_resistance/base.rb
 - lib/miyazaki_resistance/error.rb
 - lib/miyazaki_resistance/miyazaki_logger.rb
-- lib/miyazaki_resistance/tokyo_connection.rb
-- lib/miyazaki_resistance/enhance.rb
+- lib/miyazaki_resistance/connection.rb
+- lib/miyazaki_resistance/column.rb
+- lib/miyazaki_resistance/operation.rb
 - initializers/rdb.rb
 has_rdoc: true
 homepage: http://www.kaeruspoon.net/keywords/MiyazakiResistance

data/lib/miyazaki_resistance/enhance.rb

@@ -1,43 +0,0 @@
-module MiyazakiResistance
-  module Enhance
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def method_missing(name, *arguments, &block)
-        if match = finder_attribute_names(name)
-          finder = match[:finder]
-          conditions = match[:cols].map{|col| "#{col} = ?"}.join(" ")
-
-          self.class_eval %Q|
-            def self.#{name}(*args)
-              options = args.last.is_a?(::Hash) ? pop : {}
-              options.update(:conditions => ["#{conditions}", args].flatten)
-              self.find(:#{finder}, options)
-            end
-          |
-
-          __send__(name, *arguments)
-        else
-          super
-        end
-      end
-
-      private
-
-      def finder_attribute_names(name)
-        ret = {:finder => :first, :cols => nil}
-        if name.to_s =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
-          ret[:finder] = :all if $1 == "all_by"
-          if cols = $2
-            cols = cols.split("_and_")
-            all_cols = self.all_columns.keys
-            ret[:cols] = cols  if cols.all?{|col| all_cols.include?(col)}
-          end
-        end
-        (ret[:cols].nil? || ret[:cols].empty?) ? nil : ret
-      end
-    end
-  end
-end

data/lib/miyazaki_resistance/tokyo_connection.rb

@@ -1,147 +0,0 @@
-require 'yaml'
-module MiyazakiResistance
-  module TokyoConnection
-    def self.included(base)
-      base.extend ClassMethods
-      base.__send__(:include, InstanceMethods)
-    end
-
-    module ClassMethods
-      attr_accessor :connection_pool
-      attr_accessor :all_columns
-      attr_accessor :timeout_time
-
-      DEFAULT = {
-        :timeout => 5,
-        :config => "miyazakiresistance.yml",
-        :port => 1978,
-        :role => :readonly
-      }
-
-      def server_config(env, file = DEFAULT[:config])
-        env = env.to_s
-        conf = YAML.load_file(file)
-
-        if (config = conf[env]).nil?
-          logger_fatal "specified environment(#{env}) is not found in conig file(#{file})"
-          return
-        end
-
-        config["set_server"].each do |work|
-          set_server work["server"], work["port"], work["role"]
-        end
-      rescue Errno::ENOENT => e
-        logger_fatal "config file is not found : #{file}"
-      end
-
-      def set_server(host, port = DEFAULT[:port], role = DEFAULT[:role])
-        self.connection_pool ||= {:read => [], :write => nil, :standby => nil}
-        rdb = TokyoTyrant::RDBTBL.new
-        logger_info "set server host : #{host} port : #{port} role : #{role}"
-
-        rdb.set_server(host.to_s, port)
-
-        if role.to_sym == :standby
-          self.connection_pool[:standby] = rdb
-        else
-          self.connection_pool[:read] << rdb
-          self.connection_pool[:write] = rdb if role.to_sym == :write
-        end
-      end
-
-      def set_timeout(seconds)
-        self.timeout_time = seconds.to_i
-      end
-
-      def set_column(name, type, index = :no_index)
-        self.all_columns ||= {}
-        name = name.to_s
-        self.__send__(:attr_accessor, name)
-        self.all_columns.update(name => type)
-      end
-
-      def connection(con)
-        unless con.open?
-          unless con.open
-            logger_fatal "TokyoTyrantConnectError host : #{con.host} port : #{con.port}"
-            raise TokyoTyrantConnectError
-          end
-        end
-        con
-      end
-
-      def read_connection
-        check_pool
-        connection(self.connection_pool[:read].sort_by{rand}.first)
-      end
-
-      def write_connection
-        connection(self.connection_pool[:write])
-      end
-
-      def remove_pool(rdb)
-        self.connection_pool[:read].delete_if{|pool| pool == rdb}
-
-        host, port = rdb.host, rdb.port
-        new_rdb = TokyoTyrant::RDBTBL.new
-        if new_rdb.open(host, port)
-          self.connection_pool[:read] << new_rdb
-          self.connection_pool[:write] = new_rdb if rdb == self.connection_pool[:write]
-        else
-          logger_fatal "remove pool : host #{host} port : #{port}"
-          fail_over if rdb == self.connection_pool[:write]
-        end
-        rdb.close
-      end
-
-      def kaeru_timeout(&block)
-        ret = nil
-        thread = Thread.new{ret = yield}
-        raise TimeoutError, "tokyo tyrant server response error" unless thread.join(self.timeout_time || DEFAULT[:timeout])
-        ret
-      end
-
-      private
-
-      def all_connections
-        [self.connection_pool[:read], self.connection_pool[:write], self.connection_pool[:standby]].flatten.compact.uniq
-      end
-
-      def check_pool
-        return if self.connection_pool[:read] && !self.connection_pool[:read].empty?
-        logger_fatal "AllTimeoutORConnectionPoolEmpty"
-        raise AllTimeoutORConnectionPoolEmpty
-      end
-
-      def fail_over
-        unless self.connection_pool[:standby]
-          logger_fatal "MasterDropError"
-          raise MasterDropError
-        end
-
-        logger_fatal "master server failover"
-        self.connection_pool[:write] = self.connection_pool[:standby]
-        self.connection_pool[:read] << self.connection_pool[:standby]
-        self.connection_pool[:standby] = nil
-      end
-    end
-
-    module InstanceMethods
-      def read_connection
-        self.class.read_connection
-      end
-
-      def write_connection
-        self.class.write_connection
-      end
-
-      def remove_pool(rdb)
-        self.class.remove_pool(rdb)
-      end
-
-      def kaeru_timeout(&block)
-        self.class.kaeru_timeout(&block)
-      end
-    end
-  end
-end