ar-octopus-master 0.9.2.master → 0.9.2.1

data/lib/octopus/query_cache_for_shards.rb

@@ -0,0 +1,25 @@
+# query cache methods are moved to ConnectionPool for Rails >= 5.0
+module Octopus
+  module ConnectionPool
+    module QueryCacheForShards
+      %i(enable_query_cache! disable_query_cache!).each do |method|
+        define_method(method) do
+          shards = ActiveRecord::Base.connection.shards
+          if shards["master"] == self
+            shards.each do |shard_name, v|
+              if shard_name == "master"
+                super()
+              else
+                v.public_send(method)
+              end
+            end
+          else
+            super()
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::ConnectionPool.send(:prepend, Octopus::ConnectionPool::QueryCacheForShards)

data/lib/octopus/railtie.rb

@@ -0,0 +1,11 @@
+begin
+  module Octopus
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each { |ext| load ext }
+      end
+    end
+  end
+rescue LoadError
+  # nop
+end

data/lib/octopus/relation_proxy.rb

@@ -0,0 +1,58 @@
+module Octopus
+  class RelationProxy < BasicObject
+    include ::Octopus::ShardTracking::Attribute
+
+    module CaseFixer
+      def ===(other)
+        other = other.ar_relation while ::Octopus::RelationProxy === other
+        super
+      end
+    end
+
+    attr_accessor :ar_relation
+
+    def initialize(shard, ar_relation)
+      @current_shard = shard
+      @ar_relation = ar_relation
+    end
+
+    def respond_to?(*args)
+      method_missing(:respond_to?, *args)
+    end
+
+    # methods redefined in ActiveRecord that should run_on_shard
+    ENUM_METHODS = (::Enumerable.instance_methods - ::Object.instance_methods).reject do |m|
+      ::ActiveRecord::Relation.instance_method(m).source_location rescue nil
+    end + [:each, :map, :sum, :index_by]
+    # `find { ... }` etc. should run_on_shard, `find(id)` should be sent to relation
+    ENUM_WITH_BLOCK_METHODS = [:find, :select, :none?, :any?, :one?, :many?]
+
+    def method_missing(method, *args, &block)
+      if ENUM_METHODS.include?(method) || block && ENUM_WITH_BLOCK_METHODS.include?(method)
+        run_on_shard { @ar_relation.to_a }.public_send(method, *args, &block)
+      elsif block
+        @ar_relation.public_send(method, *args, &block)
+      else
+        run_on_shard do
+          if method == :load_records
+            @ar_relation.send(method, *args)
+          else
+            @ar_relation.public_send(method, *args)
+          end
+        end
+      end
+    end
+
+    def ==(other)
+      case other
+      when ::Octopus::RelationProxy
+        method_missing(:==, other.ar_relation)
+      else
+        method_missing(:==, other)
+      end
+    end
+    alias_method :eql?, :==
+  end
+end
+
+ActiveRecord::Relation.extend(Octopus::RelationProxy::CaseFixer)

data/lib/octopus/result_patch.rb

@@ -0,0 +1,19 @@
+module Octopus::ResultPatch
+  attr_accessor :current_shard
+
+  private
+
+  def hash_rows
+    if current_shard.blank?
+      super
+    else
+      foo = super
+      foo.each { |f| f.merge!('current_shard' => current_shard) }
+      foo
+    end
+  end
+end
+
+class ActiveRecord::Result
+  prepend Octopus::ResultPatch
+end

data/lib/octopus/scope_proxy.rb

@@ -0,0 +1,68 @@
+module Octopus
+  class ScopeProxy < BasicObject
+    include ::Octopus::ShardTracking::Attribute
+
+    module CaseFixer
+      def ===(other)
+        other = other.klass while ::Octopus::ScopeProxy === other
+        super
+      end
+    end
+
+    attr_accessor :klass
+
+    # Dup and clone should be delegated to the class.
+    # We want to dup the query, not the scope proxy.
+    delegate :dup, :clone, to: :klass
+
+    def initialize(shard, klass)
+      @current_shard = shard
+      @klass = klass
+    end
+
+    def using(shard)
+      fail "Nonexistent Shard Name: #{shard}" if @klass.connection.shards[shard].nil?
+      @current_shard = shard
+      self
+    end
+
+    # Transaction Method send all queries to a specified shard.
+    def transaction(options = {}, &block)
+      run_on_shard { @klass = klass.transaction(options, &block) }
+    end
+
+    def connection
+      @klass.connection_proxy.current_shard = @current_shard
+
+      if @klass.custom_octopus_connection && @klass.allowed_shard?(@current_shard)
+        # Force use of proxy, given we called 'using' explicitly to get here
+        @klass.connection_proxy.current_model = @klass
+        @klass.connection_proxy
+      else
+        @klass.connection
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      result = run_on_shard { @klass.__send__(method, *args, &block) }
+      if result.respond_to?(:all)
+        return ::Octopus::ScopeProxy.new(current_shard, result)
+      end
+
+      if result.respond_to?(:current_shard)
+        result.current_shard = current_shard
+      end
+
+      result
+    end
+
+    # Delegates to method_missing (instead of @klass) so that User.using(:blah).where(:name => "Mike")
+    # gets run in the correct shard context when #== is evaluated.
+    def ==(other)
+      method_missing(:==, other)
+    end
+    alias_method :eql?, :==
+  end
+end
+
+ActiveRecord::Relation.extend(Octopus::ScopeProxy::CaseFixer)

data/lib/octopus/shard_tracking.rb

@@ -0,0 +1,46 @@
+module Octopus
+  module ShardTracking
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # If the class which includes this module responds to the class
+      # method sharded_methods, then automagically alias_method_chain
+      # a sharding-friendly version of each of those methods into existence
+      def sharded_methods(*methods)
+        methods.each { |m| create_sharded_method(m) }
+      end
+
+      def create_sharded_method(name)
+        name.to_s =~ /([^!?]+)([!?])?/
+        method, punctuation = [Regexp.last_match[1], Regexp.last_match[2]]
+        with = :"#{method}_with_octopus#{punctuation}"
+        without = :"#{method}_without_octopus#{punctuation}"
+        define_method with do |*args, &block|
+          run_on_shard { send(without, *args, &block) }
+        end
+        alias_method without.to_sym, name.to_sym
+        alias_method name.to_sym, with.to_sym
+      end
+    end
+
+    # Adds run_on_shard method, but does not implement current_shard method
+    def run_on_shard(&block)
+      if (cs = current_shard)
+        r = ActiveRecord::Base.connection_proxy.run_queries_on_shard(cs, &block)
+        # Use a case statement to avoid any path through ActiveRecord::Delegation's
+        # respond_to? code. We want to avoid the respond_to? code because it can have
+        # the side effect of causing a call to load_target
+
+        if (ActiveRecord::Relation === r || ActiveRecord::QueryMethods::WhereChain === r) && !(Octopus::RelationProxy === r)
+          Octopus::RelationProxy.new(cs, r)
+        else
+          r
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/octopus/shard_tracking/attribute.rb

@@ -0,0 +1,22 @@
+# Adds current_shard as an attribute; provide a default
+# implementation of set_current_shard which considers
+# only the current ActiveRecord::Base.connection_proxy
+module Octopus
+  module ShardTracking
+    module Attribute
+      def self.included(base)
+        base.send(:include, Octopus::ShardTracking)
+      end
+
+      attr_accessor :current_shard
+
+      def set_current_shard
+        return unless Octopus.enabled?
+
+        if ActiveRecord::Base.connection_proxy.block
+          self.current_shard = ActiveRecord::Base.connection_proxy.current_shard
+        end
+      end
+    end
+  end
+end

data/lib/octopus/shard_tracking/dynamic.rb

@@ -0,0 +1,11 @@
+require 'octopus/shard_tracking'
+
+module Octopus
+  module ShardTracking
+    module Dynamic
+      def self.included(base)
+        base.send(:include, Octopus::ShardTracking)
+      end
+    end
+  end
+end

data/lib/octopus/singular_association.rb

@@ -0,0 +1,9 @@
+module Octopus
+  module SingularAssociation
+    def self.included(base)
+      base.sharded_methods :reader, :writer, :create, :create!, :build
+    end
+  end
+end
+
+ActiveRecord::Associations::SingularAssociation.send(:include, Octopus::SingularAssociation)

data/lib/octopus/slave_group.rb

@@ -0,0 +1,13 @@
+module Octopus
+  class SlaveGroup
+    def initialize(slaves)
+      slaves = HashWithIndifferentAccess.new(slaves)
+      slaves_list = slaves.values
+      @load_balancer = Octopus.load_balancer.new(slaves_list)
+    end
+
+    def next(options)
+      @load_balancer.next options
+    end
+  end
+end

data/lib/octopus/version.rb

@@ -0,0 +1,3 @@
+module Octopus
+  VERSION = '0.9.2.1'
+end

data/lib/tasks/octopus.rake

@@ -0,0 +1,16 @@
+namespace :octopus do
+  desc 'Copy schema version information from master to all shards'
+  task :copy_schema_versions => :environment do
+    abort('Octopus is not enabled for this environment') unless Octopus.enabled?
+
+    connection = ActiveRecord::Base.connection
+
+    current_version  = ActiveRecord::Migrator.current_version
+    migrations_paths = ActiveRecord::Migrator.migrations_paths
+
+    connection.send_queries_to_multiple_shards(connection.shard_names) do
+      ActiveRecord::Schema.initialize_schema_migrations_table
+      ActiveRecord::Schema.assume_migrated_upto_version(current_version, migrations_paths)
+    end
+  end
+end

data/sample_app/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/**/*

data/sample_app/.rspec

@@ -0,0 +1 @@
+--colour

data/sample_app/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gem 'rails', '3.2.13'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'pg'
+gem 'sqlite3'
+gem 'ar-octopus', '0.6.0'
+gem 'pry'
+
+group :test do
+  gem 'capybara'
+  gem 'cucumber-rails', :require => false
+  gem 'launchy'
+  gem 'rspec-rails'
+  gem 'aruba'
+  gem 'database_cleaner'
+end

data/sample_app/README

@@ -0,0 +1,3 @@
+== Welcome to the Octopus test app!
+
+This is a sample app, created for testing propouses.

data/sample_app/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |   |   |-- images
+  |   |   |-- javascripts
+  |   |   `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   |-- assets
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   `-- cache
+  |       `-- assets
+  `-- vendor
+      |-- assets
+      |   |-- javascripts
+      |   `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.