nobrainer_streams 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 125a83bd937986bdaa5a9c293e5117058f2a0a10
+  data.tar.gz: a2b4a215c810d771e40a17812ec15a956d17d43d
+SHA512:
+  metadata.gz: c5fe359a10db56bf735f70f8ad1fe7bab419636c7f7c4cc5d16d89911ad471ba2efc9f8b1ffdff8c4dd414b8f1664b9d653d43a0547a14b9c85a3566ea44c258
+  data.tar.gz: 6d946363a70775ee105a647089a126b844ff0528e28ce9b6ee99642f9192304ae8f2825f1a239f00dd3fb33e8f6ce4b23c753641027e932d32639bf23acedfc6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at mail@tinco.nl. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nobrainer_streams.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Tinco Andringa
+
+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,41 @@
+# NobrainerStreams
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/nobrainer_streams`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nobrainer_streams'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nobrainer_streams
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/nobrainer_streams. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nobrainer_streams"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/nobrainer_streams.rb

@@ -0,0 +1,72 @@
+require "nobrainer_streams/version"
+require "nobrainer_streams/rethinkdb_monkeypatch"
+
+module NoBrainer::Streams
+  extend ActiveSupport::Concern
+
+  included do
+    on_unsubscribe :stop_all_streams
+  end
+
+  private
+
+  def stream_from(query, options = {}, callback = nil)
+    if query.respond_to? :to_rql
+      nobrainer_stream_from(query, options, callback)
+    else
+      super(query, options, callback)
+    end
+  end
+
+  def stop_all_streams
+    nobrainer_stop_all_streams
+    super
+  end
+
+  def nobrainer_stream_from(query, options = {}, callback = nil)
+    callback ||= -> (changes) do
+      transmit changes, via: "streamed from #{query.inspect}"
+    end
+
+    # defer_subscription_confirmation!
+    connection = NoBrainer::Streams::streams_connection
+    cursor = query.to_rql.changes(options).async_run(connection, ConcurrentAsyncHandler, &callback)
+    nobrainer_cursors << cursor
+  end
+
+  def nobrainer_stop_all_streams
+    nobrainer_cursors.each do |cursor|
+      begin
+        logger.info "Closing cursor: #{cursor.inspect}"
+        cursor.close
+      rescue => e
+        logger.error "Could not close cursor: #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+    end
+  end
+  
+  def nobrainer_cursors
+    @_nobrainer_cursors ||= []
+  end
+
+  def self.streams_connection
+    @@streams_connection ||= NoBrainer::ConnectionManager.get_new_connection.raw
+  end
+
+  class ConcurrentAsyncHandler < RethinkDB::AsyncHandler
+    def run(&action)
+      options[:query_handle_class] = AsyncQueryHandler
+      yield
+    end
+
+    def handler
+      callback
+    end
+
+    class AsyncQueryHandler < RethinkDB::QueryHandle
+      def guarded_async_run(&b)
+        Concurrent.global_io_executor.post(&b)
+      end
+    end
+  end
+end

data/lib/nobrainer_streams/rethinkdb_monkeypatch.rb

@@ -0,0 +1,312 @@
+require 'rethinkdb'
+
+module RethinkDB
+  # Extend this class to define a new way of running rethinkdb queries
+  # asynchronously
+  class AsyncHandler
+    # The callback is set to be the user defined callback by the #async_run method
+    attr_accessor :callback
+    attr_accessor :connection
+    attr_accessor :options
+
+    # This method is called with a block that runs a rethinkdb connection
+    # synchronously
+    def run(&action)
+      raise "Must override AsyncHandler#run"
+    end
+
+    # This method should return a handler that will deal with incoming messages
+    def handler
+      raise "Must override AsyncHandler#handler"
+    end
+  end
+
+  # AsyncHandler that uses EventMachine to dispatch events
+  class EMHandler < AsyncHandler
+    def run
+      if !EM.reactor_running?
+        raise RuntimeError, "RethinkDB::RQL::em_run can only be called inside `EM.run`"
+      end
+
+      EM_Guard.register(connection)
+      options[:query_handle_class] = EMQueryHandle
+      yield
+    end
+
+    def handler
+      callback
+    end
+  end
+
+  class QueryHandle
+    # Override this method with an async dispatch, making sure that
+    # when the block is run @closed == false
+    def guarded_async_run(&b)
+      raise "Must override QueryHandle#guarded_async_run"
+    end
+
+    def callback(res)
+      begin
+        if @handler.stopped?
+          @closed = true
+          @conn.stop(@token)
+          return
+        elsif res
+          is_cfeed = (res['n'] & [Response::ResponseNote::SEQUENCE_FEED,
+                                  Response::ResponseNote::ATOM_FEED,
+                                  Response::ResponseNote::ORDER_BY_LIMIT_FEED,
+                                  Response::ResponseNote::UNIONED_FEED]) != []
+
+          case res['t']
+          when Response::ResponseType::SUCCESS_PARTIAL,
+               Response::ResponseType::SUCCESS_SEQUENCE
+            guarded_async_run do
+              handle_open
+              if res['t'] == Response::ResponseType::SUCCESS_PARTIAL
+                @conn.register_query(@token, @all_opts, self) if !@conn.closed?
+                @conn.dispatch([Query::QueryType::CONTINUE], @token) if !@conn.closed?
+              end
+              Shim.response_to_native(res, @msg, @all_opts).each do |row|
+                if is_cfeed
+                  if (row.has_key?('new_val') && row.has_key?('old_val') &&
+                      @handler.respond_to?(:on_change))
+                    handle(:on_change, row['old_val'], row['new_val'])
+                  elsif (row.has_key?('new_val') && !row.has_key?('old_val') &&
+                         @handler.respond_to?(:on_initial_val))
+                    handle(:on_initial_val, row['new_val'])
+                  elsif (row.has_key?('old_val') && !row.has_key?('new_val') &&
+                         @handler.respond_to?(:on_uninitial_val))
+                    handle(:on_uninitial_val, row['old_val'])
+                  elsif row.has_key?('error') && @handler.respond_to?(:on_change_error)
+                    handle(:on_change_error, row['error'])
+                  elsif row.has_key?('state') && @handler.respond_to?(:on_state)
+                    handle(:on_state, row['state'])
+                  else
+                    handle(:on_unhandled_change, row)
+                  end
+                else
+                  handle(:on_stream_val, row)
+                end
+              end
+              if res['t'] == Response::ResponseType::SUCCESS_SEQUENCE ||
+                  @conn.closed?
+                handle_close
+              end
+            end
+          when Response::ResponseType::SUCCESS_ATOM
+            guarded_async_run do
+              return if @closed
+              handle_open
+              val = Shim.response_to_native(res, @msg, @all_opts)
+              if val.is_a?(Array)
+                handle(:on_array, val)
+              else
+                handle(:on_atom, val)
+              end
+              handle_close
+            end
+          when Response::ResponseType::WAIT_COMPLETE
+            guarded_async_run do
+              return if @closed
+              handle_open
+              handle(:on_wait_complete)
+              handle_close
+            end
+          else
+            exc = nil
+            begin
+              exc = Shim.response_to_native(res, @msg, @all_opts)
+            rescue Exception => e
+              exc = e
+            end
+            guarded_async_run do
+              return if @closed
+              handle_open
+              handle(:on_error, e)
+              handle_close
+            end
+          end
+        else
+          guarded_async_run {
+            return if @closed
+            handle_close
+          }
+        end
+      rescue Exception => e
+        guarded_async_run do
+          return if @closed
+          handle_open
+          handle(:on_error, e)
+          handle_close
+        end
+      end
+    end
+  end
+
+  class EMQueryHandle < QueryHandle
+    def guarded_async_run(&b)
+      EM.next_tick {
+        b.call if !@closed
+      }
+    end
+
+    def callback(res)
+      if !EM.reactor_running?
+          @closed = true
+          @conn.stop(@token)
+          return
+      end
+      super(res)
+    end
+  end
+
+  class RQL
+    def parse(*args, &b)
+      conn = nil
+      opts = nil
+      block = nil
+      async_handler = nil
+      args = args.map{|x| x.is_a?(Class) ? x.new : x}
+      args.each {|arg|
+        case arg
+        when RethinkDB::Connection
+          raise ArgumentError, "Unexpected second Connection #{arg.inspect}." if conn
+          conn = arg
+        when Hash
+          raise ArgumentError, "Unexpected second Hash #{arg.inspect}." if opts
+          opts = arg
+        when Proc
+          raise ArgumentError, "Unexpected second callback #{arg.inspect}." if block
+          block = arg
+        when Handler
+          raise ArgumentError, "Unexpected second callback #{arg.inspect}." if block
+          block = arg
+        when AsyncHandler
+          raise ArgumentError, "Unexpected second AsyncHandler #{arg.inspect}." if async_handler
+          async_handler = arg
+        else
+          raise ArgumentError, "Unexpected argument #{arg.inspect} " +
+            "(got #{args.inspect})."
+        end
+      }
+      conn = @@default_conn if !conn
+      opts = {} if !opts
+      block = b if !block
+      if (tf = opts[:time_format])
+        opts[:time_format] = (tf = tf.to_s)
+        if tf != 'raw' && tf != 'native'
+          raise ArgumentError, "`time_format` must be 'raw' or 'native' (got `#{tf}`)."
+        end
+      end
+      if (gf = opts[:group_format])
+        opts[:group_format] = (gf = gf.to_s)
+        if gf != 'raw' && gf != 'native'
+          raise ArgumentError, "`group_format` must be 'raw' or 'native' (got `#{gf}`)."
+        end
+      end
+      if (bf = opts[:binary_format])
+        opts[:binary_format] = (bf = bf.to_s)
+        if bf != 'raw' && bf != 'native'
+          raise ArgumentError, "`binary_format` must be 'raw' or 'native' (got `#{bf}`)."
+        end
+      end
+      if !conn
+        raise ArgumentError, "No connection specified!\n" \
+        "Use `query.run(conn)` or `conn.repl(); query.run`."
+      end
+      {conn: conn, opts: opts, block: block, async_handler: async_handler}
+    end
+
+    def em_run(*args, &b)
+      async_run(*args, EMHandler, &b)
+    end
+
+    def async_run(*args, &b)
+      unbound_if(@body == RQL)
+      args = parse(*args, &b)
+      if args[:block].is_a?(Proc)
+        args[:block] = CallbackHandler.new(args[:block])
+      end
+      if !args[:block].is_a?(Handler)
+        raise ArgumentError, "No handler specified."
+      end
+
+      async_handler = args[:async_handler]
+      if !async_handler.is_a?(AsyncHandler)
+        raise ArgumentError, "No async handler specified."
+      end
+
+      # If the user has defined the `on_state` method, we assume they want states.
+      if args[:block].respond_to?(:on_state)
+        args[:opts] = args[:opts].merge(include_states: true)
+      end
+
+      async_handler.callback = args[:block]
+      async_handler.connection = args[:conn]
+      async_handler.options = args[:opts]
+
+      async_handler.run do
+        async_handler.connection.run(@body, async_handler.options, async_handler.handler)
+      end
+    end
+  end
+
+  class Connection
+    def run(msg, opts, b)
+      query_handle_class = opts.delete(:query_handle_class) || QueryHandle
+      reconnect(:noreply_wait => false) if @auto_reconnect && !is_open()
+      raise ReqlRuntimeError, "Connection is closed." if !is_open()
+
+      global_optargs = {}
+      all_opts = @default_opts.merge(opts)
+      if all_opts.keys.include?(:noreply)
+        all_opts[:noreply] = !!all_opts[:noreply]
+      end
+
+      token = new_token
+      q = [Query::QueryType::START,
+           msg,
+           Hash[all_opts.map {|k,v|
+                  [k.to_s, (v.is_a?(RQL) ? v.to_pb : RQL.new.expr(v).to_pb)]
+                }]]
+
+      if b.is_a? Handler
+        callback = query_handle_class.new(b, msg, all_opts, token, self)
+        register_query(token, all_opts, callback)
+        dispatch(q, token)
+        return callback
+      else
+        res = run_internal(q, all_opts, token)
+        return res if !res
+        if res['t'] == Response::ResponseType::SUCCESS_PARTIAL
+          value = Cursor.new(Shim.response_to_native(res, msg, opts),
+                             msg, self, opts, token, true)
+        elsif res['t'] == Response::ResponseType::SUCCESS_SEQUENCE
+          value = Cursor.new(Shim.response_to_native(res, msg, opts),
+                             msg, self, opts, token, false)
+        else
+          value = Shim.response_to_native(res, msg, opts)
+        end
+
+        if res['p']
+          real_val = {
+            "profile" => res['p'],
+            "value" => value
+          }
+        else
+          real_val = value
+        end
+
+        if b
+          begin
+            b.call(real_val)
+          ensure
+            value.close if value.is_a?(Cursor)
+          end
+        else
+          real_val
+        end
+      end
+    end
+  end
+end

data/lib/nobrainer_streams/version.rb

@@ -0,0 +1,3 @@
+module NobrainerStreams
+  VERSION = "0.1.0"
+end

data/nobrainer_streams.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nobrainer_streams/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nobrainer_streams"
+  spec.version       = NobrainerStreams::VERSION
+  spec.authors       = ["Tinco Andringa"]
+  spec.email         = ["tinco@phusion.nl"]
+
+  spec.summary       = %q{Temporary gem to add streams support to NoBrainer.}
+  spec.homepage      = "https://github.com/phusion/nobrainer_streams"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "rethinkdb", "~> 2.3"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: nobrainer_streams
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tinco Andringa
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rethinkdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: 
+email:
+- tinco@phusion.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/nobrainer_streams.rb
+- lib/nobrainer_streams/rethinkdb_monkeypatch.rb
+- lib/nobrainer_streams/version.rb
+- nobrainer_streams.gemspec
+homepage: https://github.com/phusion/nobrainer_streams
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Temporary gem to add streams support to NoBrainer.
+test_files: []