concurrent_rails 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ed13434b4d352006775b894399766908f80d8c259efa9ca8d690209d8a8b3ac6
+  data.tar.gz: 9ee145f8fa225b036e98ac2df6b2a96f6985859fcbbbe4a182faa5877ac55c9b
+SHA512:
+  metadata.gz: cb4a0a4ff89170a8ff0318b4940d240a644301be81b68bb3319170c5b55450355432e167d37bb1e1fdefd96d163e7eae3aa40cec2a9197e44d856c04904309cd
+  data.tar.gz: f5bbedb78852ae590ccfbd5c87198af855b479c491cd82b827ede998ba99269a8d88e27bb97417b6f4d7df6ee5f14c23462c2fa0e5ad0e2affb5a5b8c64d11c1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Luiz Eduardo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,138 @@
+# ConcurrentRails
+
+![status](https://github.com/luizkowalski/concurrent_rails/actions/workflows/ruby.yml/badge.svg?branch=master)
+
+Multithread is hard. [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) did an amazing job
+implementing the concepts of multithread in the Ruby world. The problem is that Rails doesn't play nice with it. Rails have a complex way of managing threads called Executor and concurrent-ruby (most specifically, [Future](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)) does not work seamlessly with it.
+
+The goal of this gem is to provide a simple library that allows the developer to work with Futures without having to care about Rails's Executor and the whole pack of problems that come with it: autoload, thread pools, active record connections, etc.
+
+## Usage
+
+This library provides two classes that will help you run tasks in parallel: `ConcurrentRails::Future` and `ConcurrentRails::Multi`
+
+### Future
+
+`ConcurrentRails::Future` will execute your code in a separated thread and you can check the progress of it whenever you need. When the task is ready, you can access the result with `#result` function:
+
+```ruby
+irb(main):001:0> future = ConcurrentRails::Future.new do
+  sleep(5) # Simulate a long running task
+  42
+end
+
+# at this point, nothing has happened yet.
+
+irb(main):002:0> future.execute
+
+irb(main):003:0> future.state
+=> :processing
+
+# after 5 seconds
+irb(main):004:0> future.state
+=> :fulfilled
+
+irb(main):005:0> future.value
+=> 42
+```
+
+A task can also fail. In this case, the state of the future will be `rejected` and the exception can be accessed by invoking `reason`
+
+```ruby
+irb(main):001:1* future = ConcurrentRails::Future.new do
+irb(main):002:1*   2 / 0
+irb(main):003:0> end.execute
+
+=> #<ConcurrentRails::Future...
+
+irb(main):004:0> future.state
+=> :rejected
+
+irb(main):005:0> future.reason
+=> #<ZeroDivisionError: divided by 0>
+```
+
+### Multi
+
+`ConcurrentRails::Multi` will let you execute multiple tasks in parallel and aggregate the results of each task when they are done. `Multi` accepts an undefined number of `Proc`s.
+
+```ruby
+irb(main):001:1* multi = ConcurrentRails::Multi.enqueue(
+irb(main):002:1*   -> { 42 },
+irb(main):003:1*   -> { :multi_test }
+irb(main):004:0> )
+
+=> #<ConcurrentRails::Multi:0x00007fbc3f9ca3f8 @actions=[#<Proc:0x00007fbc3f9ca470..
+irb(main):005:0> multi.complete?
+=> true
+
+irb(main):006:0> multi.compute
+=> [42, :multi_test]
+```
+
+Given the fact that you can send any number of `Proc`s, the result from `compute` will always be an array, even if you provide only one proc.
+
+```ruby
+irb(main):007:1* multi = ConcurrentRails::Multi.enqueue(
+irb(main):008:1*   -> { 42 }
+irb(main):009:0> )
+=> #<ConcurrentRails::Multi:0x00007fbc403f0b98 @actions=[#<Proc:0x00007...
+
+irb(main):010:0> multi.compute
+=> [42]
+```
+
+Same as `Future`, one of the `Multi` tasks can fail. You can access the exception by calling `#errors`:
+
+```ruby
+irb(main):001:1*  multi = ConcurrentRails::Multi.enqueue(
+irb(main):002:1*    -> { 42 },
+irb(main):003:1*    -> { 2 / 0 }
+irb(main):004:0>  )
+=> #<ConcurrentRails::Multi:0x00007fb46d3ee3a0 @actions=[#<Proc:0x00007..
+
+irb(main):005:0> multi.complete?
+=> true
+
+irb(main):006:0> multi.compute
+=> [42, nil]
+
+irb(main):007:0> multi.errors
+=> [#<ZeroDivisionError: divided by 0>]
+```
+
+It is worth mention that a failed proc will return `nil`.
+
+For more information on how Futures work and how Rails handle multithread check these links:
+
+[Future documentation](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)
+
+[Threading and code execution on rails](https://guides.rubyonrails.org/threading_and_code_execution.html)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'concurrent_rails'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install concurrent_rails
+```
+
+## Contributing
+
+Pull-requests are always welcome
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/concurrent_rails.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'concurrent_rails/version'
+require 'concurrent_rails/railtie'
+require 'concurrent_rails/future'
+require 'concurrent_rails/multi'
+
+module ConcurrentRails
+end

data/lib/concurrent_rails/future.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  class Future
+    extend Forwardable
+
+    def initialize(executor: :io, &block)
+      @task     = block
+      @executor = executor
+      @future   = run_on_rails(block)
+    end
+
+    def execute
+      future.execute
+
+      self
+    end
+
+    def value
+      Rails.application.executor.wrap do
+        result = nil
+
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          result = future.value
+        end
+
+        result
+      end
+    end
+
+    def_delegators :@future, :state, :reason, :rejected?, :complete?, :add_observer
+
+    private
+
+    def run_on_rails(block)
+      @future = Rails.application.executor.wrap do
+        Concurrent::Future.new(executor: executor) do
+          Rails.application.executor.wrap(&block)
+        end
+      end
+    end
+
+    attr_reader :executor, :task, :future
+  end
+end

data/lib/concurrent_rails/multi.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  class Multi
+    def self.enqueue(*actions, executor: :io)
+      unless actions.all? { |action| action.is_a?(Proc) }
+        raise ArgumentError, '#enqueue accepts `Proc`s only' 
+      end
+
+      new(actions, executor).enqueue
+    end
+
+    def initialize(actions, executor)
+      @actions    = actions
+      @executor   = executor
+      @exceptions = Concurrent::Array.new
+    end
+
+    def enqueue
+      @futures = actions.map do |action|
+        f = ConcurrentRails::Future.new(executor: executor, &action)
+        f.add_observer(self)
+        f.execute
+      end
+
+      self
+    end
+
+    def compute
+      futures.map(&:value)
+    end
+
+    def complete?
+      futures.all?(&:complete?)
+    end
+
+    def errors
+      @exceptions
+    end
+
+    private
+
+    def update(_time, _value, reason)
+      @exceptions << reason if reason
+    end
+
+    attr_reader :actions, :futures, :exceptions, :executor
+  end
+end

data/lib/concurrent_rails/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/concurrent_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  VERSION = '0.1.1'
+end

data/lib/tasks/concurrent_rails_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :concurrent_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: concurrent_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Luiz Eduardo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: Small library to make concurrent-ruby and Rails play nice together
+email:
+- luizeduardokowalski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/concurrent_rails.rb
+- lib/concurrent_rails/future.rb
+- lib/concurrent_rails/multi.rb
+- lib/concurrent_rails/railtie.rb
+- lib/concurrent_rails/version.rb
+- lib/tasks/concurrent_rails_tasks.rake
+homepage: https://github.com/luizkowalski/concurrent-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/luizkowalski/concurrent-rails
+  source_code_uri: https://github.com/luizkowalski/concurrent-rails
+  changelog_uri: https://github.com/luizkowalski/concurrent-rails/CHANGELOG
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Multithread is hard
+test_files: []