dohruby 0.2.1 → 0.3

data/lib/doh/logger_configure.rb

@@ -1,4 +1,4 @@
 require 'doh/logger/standard_interface'
 require 'doh/logger/direct_scheduler'
 require 'doh/logger/iostream_acceptor'
-require 'doh/logger/interface'
+require 'doh/logger/proxy'

data/lib/doh/merb/db_session.rb

@@ -0,0 +1,136 @@
+require 'base64'
+require 'doh/mysql'
+require 'doh/mysql/metadata_util'
+
+module DohMerb
+  @@memory_impl = {}
+  def self.retrieve_session(session_id)
+    @@memory_impl[session_id]
+  end
+end
+
+module Merb
+  module SessionMixin
+    def setup_session
+      before_value = cookies[_session_id_key]
+      request.session, cookies[_session_id_key] = Merb::DohDbSession.persist(cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(request.session.data).hash
+      @_new_cookie = cookies[_session_id_key] != before_value
+    end
+
+    def finalize_session
+      request.session.save if @_fingerprint != Marshal.dump(request.session.data).hash
+      set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
+    end
+
+    def session_store_type
+      "dohsession"
+    end
+  end
+
+  class DohDbSession
+    attr_accessor :needs_new_cookie, :session_id, :data, :updated_at
+
+    def initialize(hash = {})
+      @data = hash
+    end
+
+    class << self
+      # Generates a new session ID and creates a row for the new session in the database.
+      def generate
+        new_session = self.new({})
+        new_session.session_id = Merb::SessionMixin::rand_uuid
+        new_session
+      end
+
+      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
+      # If none is found, generates a new session.
+      def persist(session_id)
+        ensure_session_table_exists
+        if !session_id.blank?
+          row = DohDb::select_optional_row("SELECT * FROM session WHERE session_id = #{session_id.to_sql}")
+          if row
+            session = self.new(unmarshal(row['data']))
+            session.updated_at = row['updated_at']
+            session.session_id = row['session_id']
+          end
+        end
+        unless session
+          session = generate
+        end
+        [session, session.session_id]
+      end
+
+      def ensure_session_table_exists
+        return if @session_table_exists
+        if !DohDb::table_exist?('session')
+          create_session_table
+        end
+        @session_table_exists = true
+      end
+
+      def create_session_table
+        DohDb::query("CREATE TABLE session (session_id CHAR(255), data TEXT, updated_at DATETIME)")
+      end
+
+      def marshal(data) Base64.encode64(Marshal.dump(data)) if data end
+      def unmarshal(data) Marshal.load(Base64.decode64(data)) if data end
+    end
+
+    # Regenerate the Session ID
+    def regenerate
+      self.session_id = Merb::SessionMixin::rand_uuid
+      self.needs_new_cookie = true
+      self.save
+    end
+
+    # Recreates the cookie with the default expiration time
+    # Useful during log in for pushing back the expiration date
+    def refresh_expiration
+      self.needs_new_cookie = true
+    end
+
+    # delete of session data
+    def delete(key = nil)
+      key ? data.delete(key) : data.clear
+    end
+
+    def empty?
+      data.empty?
+    end
+
+    def each(&b)
+      data.each(&b)
+    end
+
+    def each_with_index(&b)
+      data.each_with_index(&b)
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    def []=(key, val)
+      data[key] = val
+    end
+
+    def delete_old_sessions
+      if !@last_deleted || @last_deleted != Date.today
+        DohDb::query("DELETE FROM session WHERE updated_at < DATE_SUB(NOW(), interval 20 day)")
+      end
+      @last_deleted = Date.today
+    end
+
+    def save
+      DohDbSession::ensure_session_table_exists
+      delete_old_sessions
+      row = DohDb::select_optional_row("SELECT updated_at FROM session WHERE session_id = #{session_id.to_sql}")
+      if row
+        DohDb::query("UPDATE session SET data = #{DohDbSession::marshal(data).to_sql}, updated_at = NOW() WHERE session_id = #{session_id.to_sql}")
+      else
+        DohDb::query("INSERT INTO session (session_id, data, updated_at) VALUES (#{session_id.to_sql}, #{DohDbSession::marshal(data).to_sql}, NOW())")
+      end
+    end
+  end
+end

data/lib/doh/merb/form_helpers.rb

@@ -0,0 +1,16 @@
+module DohMerb
+
+#kjmtodo modify to set default value based on model / field name
+  def doh_select(model, field, optionarray, opts = {})
+    result = ''
+    result += "<label>#{opts[:label]}</label>" if opts.key?(:label)
+    result += "<select name=\"#{model}[#{field}]\">\n"
+    options = optionarray.collect do |elem|
+      "<option value=\"#{elem[0]}\">#{elem[1]}</option>"
+    end
+    result += options.join("\n")
+    result += "</select>"
+    result
+  end
+
+end

data/lib/doh/merb/login.rb

@@ -3,7 +3,7 @@ require 'digest'
 
 module DohMerb
 module Login
-  attr_accessor :username_fieldname, :password_fieldname, :login_table, :login_db_name, :password_db_name, :login_page
+  attr_accessor :username_fieldname, :password_fieldname, :login_table, :login_db_name, :password_db_name, :login_page, :index_page
 
   #set the attr_accessors or override them
   def username_fieldname
@@ -26,33 +26,43 @@ module Login
     @login_page || 'login'
   end
 
+  def index_page
+    @index_page || 'index'
+  end
+
   def password_db_name
     @password_db_name || 'password'
   end
 
   def login_required
     if !authenticated?
-      Doh::log.debug "not authenticated, redirecting to #{login_page}"
+      dohlog.debug "not authenticated, redirecting to #{login_page}"
       session[:dohmerb_original_uri] = request.uri
-      Doh::log.debug("storing original uri #{request.uri.inspect}")
+      dohlog.debug("storing original uri #{request.uri.inspect}")
       redirect login_page
       throw :halt
     end
   end
 
   def authenticated?
-    Doh::log.debug("authenticated? called -- session[:dohmerb_login_username] = #{session[:dohmerb_login_username]}, session[:dohmerb_login_key] = #{session[:dohmerb_login_key]}")
-    authenticate_username_key(session[:dohmerb_login_username], session[:dohmerb_login_key])
+    dohlog.debug("authenticated? called -- session[:dohmerb_login_username] = #{session[:dohmerb_login_username]}, session[:dohmerb_login_key] = #{session[:dohmerb_login_key]}")
+    authenticate_username_key(session[:dohmerb_login_username], session[:dohmerb_login_key]) if !session[:dohmerb_login_username].to_s.strip.empty? && !session[:dohmerb_login_key].to_s.strip.empty?
   end
 
   # override this to have custom behavior
   def authenticate_username_key(username, key)
     begin
-      password = DohDb::select_field("SELECT #{password_db_name} FROM #{login_table} WHERE #{login_db_name} = #{username.to_sql}")
-      key == get_session_key(username, password)
-    rescue
-      return nil
+      row = DohDb::select_optional_row("SELECT * FROM #{login_table} WHERE #{login_db_name} = #{username.to_sql}")
+      if row
+        if key == get_session_key(username, row[password_db_name])
+          self.instance_variable_set("@#{login_table}_row", row)
+          return true
+        end
+      end
+    rescue Exception => e
+      dohlog.warn("got error: #{e.inspect} (called from authenticate_username_key) -- are you missing the table: #{login_table.inspect}?")
     end
+    return nil
   end
 
   def get_session_key(username, password)
@@ -69,10 +79,15 @@ module Login
       session[:dohmerb_login_username] = params[username_fieldname]
       session[:dohmerb_login_key] = get_session_key(params[username_fieldname], params[password_fieldname])
       if authenticated?
-        Doh::log.debug("redirecting to original uri: #{session[:dohmerb_original_uri].inspect}")
-        redirect session[:dohmerb_original_uri]
+        if session[:dohmerb_original_uri]
+          dohlog.debug("redirecting to original uri: #{session[:dohmerb_original_uri].inspect}")
+          redirect session[:dohmerb_original_uri]
+        else
+          dohlog.debug("no original uri, redirecting to index")
+          redirect index_page
+        end
       else
-        Doh::log.debug("login_helper called, not authenticated -- redirecting to login page")
+        dohlog.debug("login_helper called, not authenticated -- redirecting to login page")
         redirect login_page
       end
     end

data/lib/doh/merb/merb_dohsession.rb

@@ -0,0 +1,4 @@
+Merb.register_session_type("dohsession",
+            "doh/merb/db_session",
+            "Using DohMapper database sessions")
+

data/lib/doh/merb/notify_on_exception.rb

@@ -4,7 +4,7 @@ def notify_on_exception
   begin
     yield
   rescue Exception => e
-    Doh::log.error('Got unhandled exception', e)
+    dohlog.error('Got unhandled exception', e)
     render :inline => 'System error occured, we\'re working on it.'
   end
 end

data/lib/doh/merb/session.rb

@@ -0,0 +1,7 @@
+#this file is intended to be included from a merb applications config/init.rb file
+#after requiring this file from the init.rb, you can then use
+# c[:session_store] = 'dohsession'
+# use_orm :dohsession
+# -- at this point, you will have activated database sessions for merb
+require 'doh/app/home'
+$LOAD_PATH.unshift(File.join(Doh::home, "lib/doh/merb"))

data/lib/doh/merb/source_ip.rb

@@ -0,0 +1,10 @@
+require 'doh/util/source_ip'
+
+module DohMerb
+  def set_source_ip
+    dohlog.debug("setting source_ip to: #{request.remote_ip.inspect}")
+    Doh::set_source_ip(request.remote_ip)
+  end
+
+
+end

data/lib/doh/merb.rb

@@ -1,2 +1 @@
 require 'doh/merb/notify_on_exception'
-require 'doh/merb/post_hash'

data/lib/doh/mysql/abstract_row.rb

@@ -0,0 +1,81 @@
+module DohDb
+
+class AbstractRow
+  attr_reader :keys, :values
+  deep_dup :keys, :values
+# commented this out because in ruby 1.9 this isn't defined anymore. shouldn't be used anymore in code that uses AbstractRow anyway, so hopefully will be ok
+#  undef id
+
+  def at(index)
+    @values.at(index)
+  end
+
+  def get(key)
+    index = @keys.index(key)
+    if index
+      @values.at(index)
+    else
+      nil
+    end
+  end
+  alias [] get
+
+  def key?(key)
+    !@keys.index(key).nil?
+  end
+
+  def to_a
+    retval = []
+    @keys.size.times {|index| retval.push([@keys[index], @values[index]])}
+    retval
+  end
+
+  def to_h
+    retval = {}
+    @keys.each_with_index {|key, index| retval[key] = @values.at(index)}
+    retval
+  end
+
+  def inspect
+    ary = []
+    @keys.size.times {|index| ary.push([@keys[index], @values[index]])}
+    ary.inspect
+  end
+
+  def each_pair
+    @keys.size.times do |index|
+      yield(@keys.at(index), @values.at(index))
+    end
+  end
+
+  def size
+    @keys.size
+  end
+
+  def empty_field?(key)
+    return true if !key?(key)
+    val = get(key)
+    return val.nil? || (val.respond_to?(:empty?) && val.empty?)
+  end
+
+  # this should probably be removed eventually, but it's here for now for backwards compatibility at least
+  def record_id
+    get('id')
+  end
+
+protected
+  def parse_initialize_args(*args)
+    if args.empty?
+      [[], []]
+    elsif args[0].is_a?(Array)
+      raise "first arg is array, second must be also" unless args[1].is_a?(Array)
+      raise "first two args are arrays, must be of the same size" unless args[0].size == args[1].size
+      args
+    else
+      hash = args[0]
+      [hash.keys, hash.values] + args[1..-1]
+    end
+  end
+end
+
+end

data/lib/doh/mysql/cache_connector.rb

@@ -1,19 +1,20 @@
 require 'doh/logger'
 require 'doh/mysql/handle'
-require 'doh/mysql/raw_row_builder'
+require 'doh/mysql/typed_row_builder'
 
 module DohDb
 
 class CacheConnector
-  attr_accessor :host, :username, :password, :database, :row_builder, :timeout
+  attr_accessor :host, :username, :password, :database, :row_builder, :timeout, :port
 
   def initialize(host = nil, username = nil, password = nil, database = nil, row_builder = nil)
     @host = host
     @username = username
     @password = password
     @database = database
-    @timeout = 14400
-    @row_builder = row_builder || RawRowBuilder
+    @timeout = 1800
+    @port = nil
+    @row_builder = row_builder || TypedRowBuilder.new
   end
 
   def request_handle(database = nil)
@@ -21,6 +22,7 @@ class CacheConnector
       close_handle("handle was unused for too long") if passed_timeout?
       @handle = nil if @handle && @handle.closed?
     end
+    @last_used = Time.now
     @handle ||= get_new_handle(database)
   end
 
@@ -31,7 +33,7 @@ class CacheConnector
 private
   def close_handle(msg)
     return unless @handle
-    Doh::log.debug("DohDb::CacheConnector - closing previous database connection - #{msg}")
+    dohlog.debug("closing previous database connection - #{msg}")
     @handle.close
     @handle = nil
   end
@@ -39,9 +41,10 @@ private
   def get_new_handle(database = nil)
     database ||= @database
     dbmsg = database.to_s.strip.empty? ? 'no default database' : "database #{database}"
-    Doh::log.info("DohDb::CacheConnector - connecting to #@host as username #@username, #{dbmsg}")
-    @last_used = Time.now
-    Handle.new(Mysql.connect(@host, @username, @password, database), @row_builder)
+    dohlog.info("connecting to #@host port #@port as username #@username, #{dbmsg}")
+    mysqlh = Mysql.connect(@host, @username, @password, database, @port, nil, Mysql::CLIENT_MULTI_STATEMENTS)
+    mysqlh.query_with_result = false
+    Handle.new(mysqlh, @row_builder)
   end
 
   def passed_timeout?

data/lib/doh/mysql/connector_instance.rb

@@ -1,5 +1,4 @@
 module DohDb
-@@connector_instance = nil
 
 def self.set_connector_instance(conn)
   @@connector_instance = conn
@@ -21,16 +20,28 @@ def self.update(statement)
   request_handle.update(statement)
 end
 
+def self.update_row(statement)
+  request_handle.update_row(statement)
+end
+
+def self.update_hash(hash, table, primary_key_value, primary_key_name)
+  request_handle.update_hash(hash, table, primary_key_value, primary_key_name)
+end
+
 def self.insert(statement)
   request_handle.insert(statement)
 end
 
-def self.select(statement, row_builder = nil)
-  request_handle.select(statement, row_builder)
+def self.insert_hash(hash, table, ignore = false)
+  request_handle.insert_hash(hash, table)
 end
 
-def self.update_row(statement)
-  request_handle.update_row(statement)
+def self.replace_hash(hash, table)
+  request_handle.replace_hash(hash, table)
+end
+
+def self.select(statement, row_builder = nil)
+  request_handle.select(statement, row_builder)
 end
 
 def self.select_row(statement, row_builder = nil)
@@ -49,4 +60,20 @@ def self.select_optional_field(statement, row_builder = nil)
   request_handle.select_optional_field(statement, row_builder)
 end
 
+def self.select_transpose(statement, row_builder = nil)
+  request_handle.select_transpose(statement, row_builder)
+end
+
+def self.select_values(statement, row_builder = nil)
+  request_handle.select_values(statement, row_builder)
+end
+
+def self.select_list(statement, row_builder = nil)
+  request_handle.select_list(statement, row_builder)
+end
+
+def self.multi_select(statements)
+  request_handle.multi_select(statements)
+end
+
 end

data/lib/doh/mysql/connector_util.rb

@@ -21,6 +21,7 @@ def self.reconfigure_connector(cfg, connector = nil)
   connector.username = cfg['username'] if cfg.key?('username')
   connector.password = cfg['password'] if cfg.key?('password')
   connector.database = cfg['database'] if cfg.key?('database')
+  connector.port = cfg['port'] if cfg.key?('port')
 end
 
 end

data/lib/doh/mysql/convert.rb

@@ -0,0 +1,18 @@
+require 'doh/mysql/metadata_util'
+require 'doh/mysql/error'
+
+module DohDb
+
+def self.convert(table, column, value)
+  info = column_info(table)[column]
+#  raise UnknownColumn, "#{table}.#{column}" if info.nil?
+  return value if info.nil?
+  if value.nil?
+    raise CannotBeNull, "#{table}.#{column}" if info['is_nullable'] == 'NO'
+    return nil
+  end
+  return nil if value.is_a?(String) && value.empty? && info['is_nullable'] == 'YES'
+  value
+end
+
+end

data/lib/doh/mysql/database_creator.rb

@@ -1,8 +1,8 @@
 require 'doh/core/dir'
 require 'doh/mysql/handle'
 require 'doh/mysql/load_sql'
-require 'doh/mysql/connector_instance'
-require 'yaml'
+require 'doh/mysql/version'
+require 'doh/mysql/types'
 
 module DohDb
 
@@ -10,6 +10,7 @@ class DatabaseCreator
   def initialize(data_directory = nil, connector = nil)
     @data_directory = data_directory || File.join(DohApp::home, 'database')
     @connector = connector || DohDb::connector_instance
+    @include_scripts = true
   end
 
   def create_database(dbname, drop_first = false)
@@ -18,6 +19,7 @@ class DatabaseCreator
 
   def create_database_copy(dest_db, source_db, drop_first = false)
     create_one_database(get_nodb_handle, dest_db, source_db, drop_first)
+    DohDb::link_database_types(dest_db, source_db)
   end
 
   def create_all_databases(drop_first = false)
@@ -26,11 +28,17 @@ class DatabaseCreator
   end
 
   def create_tables(database, drop_first, *table_and_view_names)
+    @connector.database = database
     views, tables = table_and_view_names.flatten.sort.partition {|name| File.exist?(sql_filename(database, 'views', name))}
     tables.each {|name| create_base_table(database, name, drop_first)}
     views.each {|name| create_view(database, name, drop_first)}
   end
 
+  def exclude_scripts
+    @include_scripts = false
+    self
+  end
+
 private
   def get_nodb_handle
     @connector.reset
@@ -45,7 +53,7 @@ private
   def find_files(source_db, subdir, ext = '.sql')
     path = File.join(@data_directory, source_db, subdir)
     return [] unless File.exist?(path)
-    Dir.entries(path).find_all {|entry| entry.ends_with(ext)}.sort.collect {|elem| File.join(path, elem)}
+    Dir.entries(path).find_all {|entry| entry.end_with?(ext)}.sort.collect {|elem| File.join(path, elem)}
   end
 
   def view_files(source_db)
@@ -69,17 +77,22 @@ private
   end
 
   def create_one_database(dbh, dest_db, source_db, drop_first)
-    Doh::log.info("DohDb::DatabaseCreator - creating source database " + source_db + " inside " + dest_db)
+    dohlog.info("creating database " + dest_db + " from source files at " + File.join(@data_directory, source_db))
     dbh.query("DROP DATABASE IF EXISTS " + dest_db) if drop_first
 
     dbh.query("CREATE DATABASE " + dest_db)
     dbh.query("USE " + dest_db)
+    dbh.query("CREATE TABLE version (version INT UNSIGNED NOT NULL) ENGINE=MyISAM")
+    dbver = DohDb::latest_database_version(source_db)
+    dbh.query("INSERT INTO version VALUES (#{dbver})")
+
     @connector.database = dest_db
 
     files = find_files(source_db, 'tables') + find_files(source_db, 'insert_sql') + view_files(source_db)
     DohDb::load_sql_connector(files, @connector, dest_db)
+    return unless @include_scripts
     find_files(source_db, 'insert_scripts', '.rb').each do |filename|
-      Doh::log.info("loading file: #{filename}")
+      dohlog.info("loading file: #{filename}")
       load(filename)
     end
   end

data/lib/doh/mysql/db_date.rb

@@ -21,8 +21,8 @@ def self.today
 end
 
 def self.now
-  dt = DateTime.now
-  DateTimeNow.new(dt.year, dt.month, dt.mday, dt.hour, dt.min, dt.sec)
+  dt = DateTime.zow
+  DateTimeNow.new(dt.year, dt.month, dt.mday, dt.hour, dt.min, dt.sec, dt.zone)
 end
 
 end

data/lib/doh/mysql/default_type_guesser.rb

@@ -1,17 +1,34 @@
 require 'mysql'
 require 'doh/mysql/parse'
+require 'doh/util/to_display'
+require 'doh/mysql/types'
 
 module DohDb
 
 class DefaultTypeGuesser
-  def guess_type(value, meta)
+  # for compatibility with older mysql gems
+  if !MysqlField.const_defined?('TYPE_NEWDECIMAL')
+    MysqlField::TYPE_NEWDECIMAL = 246
+  end
+  DECIMAL_TYPES = [MysqlField::TYPE_DECIMAL, MysqlField::TYPE_NEWDECIMAL]
+  INT_TYPES = [MysqlField::TYPE_TINY,MysqlField::TYPE_SHORT,MysqlField::TYPE_LONG,MysqlField::TYPE_LONGLONG,MysqlField::TYPE_INT24]
+
+  def self.guess_type(value, meta)
     return nil if value.nil?
+
+    custom_type = DohDb::find_column_type(nil, meta.table, meta.name) || DohDb::find_column_type(nil, nil, meta.name)
+    return custom_type.build(meta.name, value) if custom_type
+
     return DohDb::parse_bool(value) if (meta.type == MysqlField::TYPE_TINY) && (meta.length == 1) && (meta.max_length == 1)
     return DohDb::parse_datetime(value) if meta.type == MysqlField::TYPE_DATETIME
     return DohDb::parse_date(value) if meta.type == MysqlField::TYPE_DATE
-    return DohDb::parse_decimal(value) if meta.type == MysqlField::TYPE_NEWDECIMAL
-    return DohDb::parse_decimal(value) if meta.type == MysqlField::TYPE_DECIMAL
-    return DohDb::parse_int(value) if (meta.flags & MysqlField::NUM_FLAG) == MysqlField::NUM_FLAG
+    return DohDb::parse_decimal(value) if DECIMAL_TYPES.include?(meta.type)
+    return DohDb::parse_int(value) if INT_TYPES.include?(meta.type)
+    if meta.type == MysqlField::TYPE_STRING || meta.type == MysqlField::TYPE_VAR_STRING
+      return PhoneDisplayString.new(value) if (value.size == 10) && (meta.name.lastn(5) == 'phone')
+      return SsnDisplayString.new(value) if (value.size == 9) && (meta.max_length == 9) && (meta.name.lastn(3) == 'ssn')
+      return PostalDisplayString.new(value) if [5,9].include?(value.size) && [5,9].include?(meta.max_length) && ((meta.name.lastn(6) == 'postal') || (meta.name.lastn(3) == 'zip'))
+    end
     value
   end
 end

data/lib/doh/mysql/error.rb

@@ -1,6 +1,7 @@
 module DohDb
 
-class QueryResultError < StandardError
-end
+class UnexpectedQueryResult < StandardError; end
+class UnknownColumn < StandardError; end
+class CannotBeNull < StandardError; end
 
 end