nobrainer 0.22.0 → 0.28.0

data/lib/no_brainer/document/validation/uniqueness.rb

@@ -1,55 +1,48 @@
 module NoBrainer::Document::Validation::Uniqueness
   extend ActiveSupport::Concern
 
-  def _create(options={})
+  # XXX we don't use read_attribute_for_validation, which goes through the user
+  # getters, but read internal attributes instead. It makes more sense.
+
+  def save?(options={})
     lock_unique_fields
     super
   ensure
     unlock_unique_fields
   end
 
-  def _update_only_changed_attrs(options={})
-    lock_unique_fields
-    super
-  ensure
-    unlock_unique_fields
+  def _lock_for_uniqueness_once(key)
+    @locked_keys_for_uniqueness ||= {}
+    @locked_keys_for_uniqueness[key] ||= NoBrainer::Config.distributed_lock_class.new(key).tap(&:lock)
   end
 
-  def _lock_key_from_field(field)
-    value = read_attribute(field).to_s
-    ['nobrainer', self.class.database_name || NoBrainer.connection.parsed_uri[:db],
-     self.class.table_name, field, value.empty? ? 'nil' : value].join(':')
+  def unlock_unique_fields
+    (@locked_keys_for_uniqueness || {}).values.each(&:unlock)
+    @locked_keys_for_uniqueness = {}
   end
 
   def lock_unique_fields
-    return unless NoBrainer::Config.distributed_lock_class && !self.class.unique_validators.empty?
-
     self.class.unique_validators
-      .map { |validator| validator.attributes.map { |attr| [attr, validator] } }
-      .flatten(1)
+      .flat_map { |validator| validator.attributes.map { |attr| [attr, validator] } }
       .select { |f, validator| validator.should_validate_field?(self, f) }
-      .map { |f, options| _lock_key_from_field(f) }
-      .sort
-      .uniq
-      .each do |key|
-        lock = NoBrainer::Config.distributed_lock_class.new(key)
-        lock.lock
-        @locked_unique_fields ||= []
-        @locked_unique_fields << lock
-      end
-  end
-
-  def unlock_unique_fields
-    return unless @locked_unique_fields
-    @locked_unique_fields.pop.unlock until @locked_unique_fields.empty?
+      .map { |f, validator| [f, *validator.scope].map { |k| [k, _read_attribute(k)] } }
+      .map { |params| self.class._uniqueness_key_name_from_params(params) }
+      .sort.each { |key| _lock_for_uniqueness_once(key) }
   end
 
   included do
     singleton_class.send(:attr_accessor, :unique_validators)
     self.unique_validators = []
+    attr_accessor :locked_keys_for_uniqueness
   end
 
   module ClassMethods
+    def _uniqueness_key_name_from_params(params)
+      ['uniq', NoBrainer.current_db, self.table_name,
+       *params.map { |k,v| [k.to_s, (v = v.to_s; v.empty? ? 'nil' : v)] }.sort
+      ].join(':')
+    end
+
     def validates_uniqueness_of(*attr_names)
       validates_with(UniquenessValidator, _merge_attributes(attr_names))
     end
@@ -61,14 +54,15 @@ module NoBrainer::Document::Validation::Uniqueness
   end
 
   class UniquenessValidator < ActiveModel::EachValidator
-    attr_accessor :scope
+    attr_accessor :scope, :model
 
     def initialize(options={})
       super
-      model = options[:class]
-      self.scope = [*options[:scope]]
-      ([model] + model.descendants).each do |_model|
-        _model.unique_validators << self
+      self.model = options[:class]
+      self.scope = [*options[:scope]].map(&:to_sym)
+
+      model.subclass_tree.each do |subclass|
+        subclass.unique_validators << self
       end
     end
 
@@ -77,7 +71,7 @@ module NoBrainer::Document::Validation::Uniqueness
     end
 
     def validate_each(doc, attr, value)
-      criteria = doc.root_class.unscoped.where(attr => value)
+      criteria = self.model.unscoped.where(attr => value)
       criteria = apply_scopes(criteria, doc)
       criteria = exclude_doc(criteria, doc) if doc.persisted?
       doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless criteria.empty?
@@ -89,11 +83,11 @@ module NoBrainer::Document::Validation::Uniqueness
     end
 
     def apply_scopes(criteria, doc)
-      criteria.where(scope.map { |k| {k => doc.read_attribute(k)} })
+      criteria.where(scope.map { |k| {k => doc._read_attribute(k)} })
     end
 
     def exclude_doc(criteria, doc)
-      criteria.where(doc.class.pk_name.ne => doc.pk_value)
+      criteria.where(doc.class.pk_name.not => doc.pk_value)
     end
   end
 end

data/lib/no_brainer/document/validation.rb

@@ -1,63 +1,6 @@
 module NoBrainer::Document::Validation
   extend NoBrainer::Autoload
   extend ActiveSupport::Concern
-  include ActiveModel::Validations
-  include ActiveModel::Validations::Callbacks
 
-  autoload_and_include :Uniqueness, :NotNull
-
-  included do
-    # We don't want before_validation returning false to halt the chain.
-    define_callbacks :validation, :skip_after_callbacks_if_terminated => true,
-                     :scope => [:kind, :name], :terminator => proc { false }
-  end
-
-  def valid?(context=nil, options={})
-    context ||= new_record? ? :create : :update
-
-   # XXX Monkey Patching, because we need to have control on errors.clear
-    current_context, self.validation_context = validation_context, context
-    errors.clear unless options[:clear_errors] == false
-    run_validations!
-  ensure
-    self.validation_context = current_context
-  end
-
-  SHORTHANDS = { :format => :format, :length => :length, :required => :presence,
-                 :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
-
-  module ClassMethods
-    def _field(attr, options={})
-      super
-
-      shorthands = SHORTHANDS
-      shorthands = shorthands.merge(:required => :not_null) if options[:type] == NoBrainer::Boolean
-      shorthands.each { |k,v| validates(attr, v => options[k]) if options.has_key?(k) }
-
-      validates(attr, options[:validates]) if options[:validates]
-      validates(attr, :length => { :minimum => options[:min_length] }) if options[:min_length]
-      validates(attr, :length => { :maximum => options[:max_length] }) if options[:max_length]
-    end
-  end
-end
-
-class ActiveModel::EachValidator
-  def should_validate_field?(record, attribute)
-    return true unless record.is_a?(NoBrainer::Document)
-    return true if record.new_record?
-
-    attr_changed = "#{attribute}_changed?"
-    return record.respond_to?(attr_changed) ? record.__send__(attr_changed) : true
-  end
-
-  # XXX Monkey Patching :(
-  def validate(record)
-    attributes.each do |attribute|
-      next unless should_validate_field?(record, attribute) # <--- Added
-      value = record.read_attribute_for_validation(attribute)
-      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- Added
-      next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
-      validate_each(record, attribute, value)
-    end
-  end
+  autoload_and_include :Core, :Uniqueness, :NotNull
 end

data/lib/no_brainer/document.rb

@@ -4,8 +4,8 @@ module NoBrainer::Document
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
-  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
-                       :Persistance, :Validation, :Types, :Callbacks, :Dirty, :PrimaryKey,
+  autoload_and_include :Core, :TableConfig, :InjectionLayer, :Attributes, :Readonly,
+                       :Persistance, :Callbacks, :Validation, :Types, :Dirty, :PrimaryKey,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
                        :MissingAttributes, :LazyFetch, :AtomicOps
 

data/lib/no_brainer/error.rb

@@ -12,6 +12,7 @@ module NoBrainer::Error
   class AtomicBlock             < RuntimeError; end
   class LostLock                < RuntimeError; end
   class LockUnavailable         < RuntimeError; end
+  class InvalidPolymorphicType  < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/geo/base.rb

@@ -9,7 +9,6 @@ module NoBrainer::Geo::Base
 
     options[:unit] = unit if unit && unit.to_s != 'm'
     options[:geo_system] = geo_system if geo_system && geo_system.to_s != 'WGS84'
-    options[:max_dist] = options.delete(:max_distance) if options[:max_distance]
 
     options
   end

data/lib/no_brainer/locale/en.yml

@@ -4,3 +4,4 @@ en:
       taken: "is already taken"
       invalid_type: "should be a %{type}"
       undefined: "must be defined"
+      invalid_foreign_key: "is an invalid foreign key: %{target_model}(%{primary_key}: %{value}) is not found"

data/lib/no_brainer/lock.rb

@@ -3,7 +3,7 @@ require 'digest/sha1'
 class NoBrainer::Lock
   include NoBrainer::Document
 
-  store_in :table => 'nobrainer_locks'
+  table_config :name => 'nobrainer_locks'
 
   # Since PKs are limited to 127 characters, we can't use the user's key as a PK
   # as it could be arbitrarily long.
@@ -30,12 +30,16 @@ class NoBrainer::Lock
     super(options.merge(:key => key))
   end
 
-  def lock(options={}, &block)
-    if block
-      lock(options)
-      return block.call.tap { unlock }
+  def synchronize(options={}, &block)
+    lock(options)
+    begin
+      block.call
+    ensure
+      unlock if @locked
     end
+  end
 
+  def lock(options={})
     options.assert_valid_keys(:expire, :timeout)
     timeout = NoBrainer::Config.lock_options.merge(options)[:timeout]
     sleep_amount = 0.1
@@ -102,13 +106,13 @@ class NoBrainer::Lock
     end
   end
 
+  def save?(*);  raise NotImplementedError; end
+  def delete(*); raise NotImplementedError; end
+
   private
 
   def set_expiration(options)
     expire = NoBrainer::Config.lock_options.merge(options)[:expire]
     self.expires_at = RethinkDB::RQL.new.now + expire
   end
-
-  def save?; raise; end
-  def delete; raise; end
 end

data/lib/no_brainer/profiler/controller_runtime.rb

@@ -0,0 +1,76 @@
+# Rails specific. TODO Test
+module NoBrainer::Profiler::ControllerRuntime
+  extend ActiveSupport::Concern
+
+  class Profiler
+    attr_accessor :write_duration, :read_duration, :other_duration
+    def initialize
+      @write_duration = @read_duration = @other_duration = 0.0
+    end
+
+    def total_duration
+      read_duration + write_duration + other_duration
+    end
+
+    def add_query(env)
+      case env[:query_type]
+      when :write      then @write_duration += env[:duration]
+      when :read       then @read_duration  += env[:duration]
+      else                  @other_duration += env[:duration]
+      end
+    end
+
+    def self.spawn_controller_profiler
+      Thread.current[:nobrainer_controller_profiler] = new
+    end
+
+    def self.cleanup_controller_profiler
+      Thread.current[:nobrainer_controller_profiler] = nil
+    end
+
+    def self.current
+      Thread.current[:nobrainer_controller_profiler]
+    end
+
+    def self.on_query(env)
+      current.try(:add_query, env)
+    end
+
+    NoBrainer::Profiler.register(self)
+  end
+
+  def process_action(action, *args)
+    Profiler.spawn_controller_profiler
+    super
+  ensure
+    Profiler.cleanup_controller_profiler
+  end
+
+  def cleanup_view_runtime
+    time_spent_in_db_before_views = Profiler.current.total_duration
+    runtime = super
+    time_spent_in_db_after_views = Profiler.current.total_duration
+
+    time_spent_in_db_during_views = (time_spent_in_db_after_views - time_spent_in_db_before_views) * 1000
+    runtime - time_spent_in_db_during_views
+  end
+
+  def append_info_to_payload(payload)
+    super
+    payload[:nobrainer_profiler] = Profiler.current
+  end
+
+  module ClassMethods # :nodoc:
+    def log_process_action(payload)
+      messages, profiler = super, payload[:nobrainer_profiler]
+      if profiler && !profiler.total_duration.zero?
+        msg = []
+        msg << "%.1fms (write)" % (profiler.write_duration * 1000) unless profiler.write_duration.zero?
+        msg << "%.1fms (read)"  % (profiler.read_duration  * 1000) unless profiler.read_duration.zero?
+        msg << "%.1fms (other)" % (profiler.other_duration * 1000) unless profiler.other_duration.zero?
+        messages << "NoBrainer: #{msg.join(", ")}"
+      end
+      messages
+    end
+  end
+end

data/lib/no_brainer/{query_runner → profiler}/logger.rb

@@ -1,41 +1,29 @@
-class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
-  def call(env)
-    start_time = Time.now
-    @runner.call(env).tap { log_query(env, start_time) }
-  rescue Exception => e
-    log_query(env, start_time, e)
-    raise e
-  end
-
-  private
-
-  def log_query(env, start_time, exception=nil)
-    return if handle_on_demand_exception?(env, exception)
-
+class NoBrainer::Profiler::Logger
+  def on_query(env)
     not_indexed = env[:criteria] && env[:criteria].where_present? &&
                     !env[:criteria].where_indexed? &&
                     !env[:criteria].model.try(:perf_warnings_disabled)
 
-    level = exception ? Logger::ERROR :
+    level = env[:exception] ? Logger::ERROR :
              not_indexed ? Logger::INFO : Logger::DEBUG
-    return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
+    return if NoBrainer.logger.level > level
 
-    duration = Time.now - start_time
-
-    msg_duration = (duration * 1000.0).round(1).to_s
+    msg_duration = (env[:duration] * 1000.0).round(1).to_s
     msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
     msg_duration = "[#{msg_duration}ms] "
 
-    msg_db = "[#{env[:db_name]}] " if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
+    env[:query_type] = NoBrainer::RQL.type_of(env[:query])
+
+    msg_db = "[#{env[:options][:db]}] " if env[:options][:db]
     msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
 
-    msg_exception = "#{exception.class} #{exception.message.split("\n").first}" if exception
+    msg_exception = "#{env[:exception].class} #{env[:exception].message.split("\n").first}" if env[:exception]
     msg_exception ||= "perf: filtering without using an index" if not_indexed
 
     msg_last = nil
 
     if NoBrainer::Config.colorize_logger
-      query_color = case NoBrainer::RQL.type_of(env[:query])
+      query_color = case env[:query_type]
                     when :write      then "\e[1;31m" # red
                     when :read       then "\e[1;32m" # green
                     when :management then "\e[1;33m" # yellow
@@ -53,9 +41,5 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     NoBrainer.logger.add(level, msg)
   end
 
-  def handle_on_demand_exception?(env, e)
-    # pretty gross I must say.
-    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).handle_database_on_demand_exception?(env, e) ||
-          NoBrainer::QueryRunner::TableOnDemand.new(nil).handle_table_on_demand_exception?(env, e))
-  end
+  NoBrainer::Profiler.register(self.new)
 end

data/lib/no_brainer/profiler.rb

@@ -0,0 +1,11 @@
+module NoBrainer::Profiler
+  class << self
+    attr_accessor :registered_profilers
+
+    def register(profiler)
+      self.registered_profilers << profiler
+    end
+  end
+
+  self.registered_profilers = []
+end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -2,8 +2,8 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   def call(env)
     @runner.call(env)
   rescue RuntimeError => e
-    if database_name = handle_database_on_demand_exception?(env, e)
-      auto_create_database(env, database_name)
+    if db_name = handle_database_on_demand_exception?(env, e)
+      auto_create_database(env, db_name)
       retry
     end
     raise
@@ -15,15 +15,15 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
 
   private
 
-  def auto_create_database(env, database_name)
-    if env[:last_auto_create_database] == database_name
-      raise "Auto database creation is not working with #{database_name}"
+  def auto_create_database(env, db_name)
+    if env[:last_auto_create_database] == db_name
+      raise "Auto database creation is not working with #{db_name}"
     end
-    env[:last_auto_create_database] = database_name
+    env[:last_auto_create_database] = db_name
 
-    NoBrainer.db_create(database_name)
+    NoBrainer.run { |r| r.db_create(db_name) }
   rescue RuntimeError => e
     # We might have raced with another db_create
-    raise unless e.message =~ /Database `#{database_name}` already exists/
+    raise unless e.message =~ /Database `#{db_name}` already exists/
   end
 end

data/lib/no_brainer/query_runner/driver.rb

@@ -1,5 +1,7 @@
 class NoBrainer::QueryRunner::Driver < NoBrainer::QueryRunner::Middleware
   def call(env)
-    env[:query].run(NoBrainer.connection.raw, env[:options])
+    options = env[:options]
+    options = options.merge(:db => RethinkDB::RQL.new.db(options[:db])) if options[:db]
+    env[:query].run(NoBrainer.connection.raw, options)
   end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -4,7 +4,7 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
   rescue RethinkDB::RqlRuntimeError => e
     if e.message =~ /^Index `(.+)` was not found on table `(.+)\.(.+)`\.$/
       index_name = $1
-      database_name = $2
+      db_name = $2
       table_name = $3
 
       model = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
@@ -12,10 +12,10 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
       index_name = index.name if index
 
       if model.try(:pk_name).try(:to_s) == index_name.to_s
-        err_msg  = "Please update the primary key `#{index_name}` in the table `#{database_name}.#{table_name}`."
+        err_msg  = "Please update the primary key `#{index_name}` in the table `#{db_name}.#{table_name}`."
       else
         err_msg  = "Please run `NoBrainer.sync_indexes' or `rake nobrainer:sync_indexes' to create the index `#{index_name}`"
-        err_msg += " in the table `#{database_name}.#{table_name}`."
+        err_msg += " in the table `#{db_name}.#{table_name}`."
         err_msg += " Read http://nobrainer.io/docs/indexes for more information."
       end
 

data/lib/no_brainer/query_runner/profiler.rb

@@ -0,0 +1,43 @@
+class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    profiler_start(env)
+    @runner.call(env).tap { profiler_end(env) }
+  rescue Exception => e
+    profiler_end(env, e)
+    raise e
+  end
+
+  private
+
+  require 'no_brainer/profiler/logger'
+
+  def profiler_start(env)
+    env[:start_time] = Time.now
+  end
+
+  def profiler_end(env, exception=nil)
+    return if handle_on_demand_exception?(env, exception)
+
+    env[:end_time] = Time.now
+    env[:duration] = env[:end_time] - env[:start_time]
+    env[:exception] = exception
+
+    env[:model] = env[:criteria] && env[:criteria].model
+    env[:query_type] = NoBrainer::RQL.type_of(env[:query])
+
+    NoBrainer::Profiler.registered_profilers.each do |profiler|
+      begin
+        profiler.on_query(env)
+      rescue Exception => e
+        STDERR.puts "[NoBrainer] Profiling error: #{e.class} #{e.message}"
+      end
+    end
+  end
+
+  def handle_on_demand_exception?(env, e)
+    # pretty gross I must say.
+    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).handle_database_on_demand_exception?(env, e) ||
+          NoBrainer::QueryRunner::TableOnDemand.new(nil).handle_table_on_demand_exception?(env, e))
+  end
+end
+

data/lib/no_brainer/query_runner/reconnect.rb

@@ -2,28 +2,44 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
   rescue StandardError => e
-    context ||= { :retries => NoBrainer::Config.max_retries_on_connection_failure }
     if is_connection_error_exception?(e)
-      if NoBrainer::Config.max_retries_on_connection_failure == 0
-        NoBrainer.disconnect
-      else
-        # XXX Possibly dangerous, as we could reexecute a non idempotent operation
-        # Check the semantics of the db
-        retry if reconnect(e, context)
-      end
+      context ||= {}
+      # XXX Possibly dangerous, as we could reexecute a non idempotent operation
+      retry if reconnect(e, context)
     end
     raise
   end
 
   private
 
+  def max_tries
+    NoBrainer::Config.max_retries_on_connection_failure
+  end
+
   def reconnect(e, context)
-    return false if context[:retries].zero?
-    context[:retries] -= 1
+    context[:connection_retries] ||= max_tries
+    context[:previous_connection] ||= NoBrainer.connection
+    NoBrainer.disconnect
+
+    unless context[:lost_connection_logged]
+      context[:lost_connection_logged] = true
+
+      msg = server_not_ready?(e) ? "Server %s not ready: %s" : "Connection issue with %s: %s"
+      NoBrainer.logger.warn(msg % [context[:previous_connection].try(:uri), exception_msg(e)])
+    end
+
+    if context[:connection_retries].zero?
+      NoBrainer.logger.info("Retry limit exceeded (#{max_tries}). Giving up.")
+      return false
+    end
+    context[:connection_retries] -= 1
 
-    warn_reconnect(e)
     sleep 1
-    NoBrainer.connection.reconnect(:noreply_wait => false)
+
+    c = NoBrainer.connection
+    NoBrainer.logger.info("Connecting to #{c.uri}... (last error: #{exception_msg(e)})")
+    c.connect
+
     true
   rescue StandardError => e
     retry if is_connection_error_exception?(e)
@@ -36,21 +52,20 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
       Errno::ECONNRESET, Errno::ETIMEDOUT, IOError
       true
     when RethinkDB::RqlRuntimeError
-      e.message =~ /No master available/ ||
-      e.message =~ /Master .* not available/ ||
-      e.message =~ /Error: Connection Closed/
+      e.message =~ /lost contact/ ||
+      e.message =~ /(P|p)rimary .* not available/||
+      e.message =~ /Connection.*closed/
     else
       false
     end
   end
 
-  def warn_reconnect(e)
-    if e.is_a?(RethinkDB::RqlRuntimeError)
-      e_msg = e.message.split("\n").first
-      msg = "Server #{NoBrainer::Config.rethinkdb_url} not ready - #{e_msg}, retrying..."
-    else
-      msg = "Connection issue with #{NoBrainer::Config.rethinkdb_url} - #{e}, retrying..."
-    end
-    NoBrainer.logger.try(:warn, msg)
+  def exception_msg(e)
+    e.is_a?(RethinkDB::RqlRuntimeError) ? e.message.split("\n").first : e.to_s
+  end
+
+  def server_not_ready?(e)
+    e.message =~ /lost contact/ ||
+    e.message =~ /(P|p)rimary .* not available/
   end
 end