hyper-operation 1.0.alpha1.5 → 1.0.alpha1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65b352cb39f23e41aa0f4adc29ba892a8d9cf269c7345314851f2a68bccddf86
-  data.tar.gz: 71f10e8f1dfc3f38b968b694c0535169211a374dc404fa3da79a864791e075f2
+  metadata.gz: bf7ea211cf5d34d735df9a5318691ff4261b26e15816c6529138da58ce23ead5
+  data.tar.gz: bbce8cdf73f646fe7abd922a0667739f486368c723800b7f6efecbbec9ad7468
 SHA512:
-  metadata.gz: ba63a89809105c28b96d246a9958d0aab4ea121bcd59d5ee0f7fb1f96d88b1832dcafe35421f8220a13b401acba73d08cf7b27ce798c382336a2c9d844e7533f
-  data.tar.gz: afaea58dfe7c97007f3d70cebe53d02258c938e3fa4c863788a259f2478fbf45dcf7bc8472fc46967c60b797b693594d1e2468b45671b58281bcaed2925e7e0f
+  metadata.gz: afdb25d53a08ed95794a3419f0d3ea341f04c8da594d68189029f2c5c87568b4c0edd9fe4b57df4a42042f63f66de585e4a1a65dde8efb56063d79019fddee75
+  data.tar.gz: c5fbd8014773c171dee7d8556f84da60fcdfc77509a7ae6f4380c3b7b729a2c438faa4cd5c1d09a92dc19ceed2b77203154314ebd75b6e3b01988383485caf88

data/.travis.yml

@@ -7,6 +7,7 @@ rvm:
   - ruby-head
 services:
   - mysql
+  - redis-server
 env:
   - DRIVER=google-chrome TZ=Europe/Berlin
 matrix:

data/hyper-operation.gemspec

@@ -29,24 +29,25 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'opal-activesupport', '~> 0.3.1'
   spec.add_dependency 'tty-table'
 
-  spec.add_development_dependency 'bundler', ['>= 1.17.3', '< 2.1']
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'chromedriver-helper'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'hyper-spec', Hyperstack::Operation::VERSION
   spec.add_development_dependency 'mysql2'
-  spec.add_development_dependency 'opal', '>= 0.11.0', '< 0.12.0'
   spec.add_development_dependency 'opal-browser', '~> 0.2.0'
-  spec.add_development_dependency 'opal-rails', '~> 0.9.4'
+  spec.add_development_dependency 'opal-rails', '>= 0.9.4', '< 2.0'
   spec.add_development_dependency 'pry-rescue'
+  spec.add_development_dependency 'pry-stack_explorer'
   spec.add_development_dependency 'puma'
   spec.add_development_dependency 'pusher'
   spec.add_development_dependency 'pusher-fake'
-  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'rails', ENV['RAILS_VERSION'] || '>= 5.0.0', '< 7.0'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'react-rails', '>= 2.4.0', '< 2.5.0'
+  spec.add_development_dependency 'redis'
   spec.add_development_dependency 'rspec-rails'
   spec.add_development_dependency 'rspec-steps', '~> 2.1.1'
   spec.add_development_dependency 'rspec-wait'
-  spec.add_development_dependency 'sqlite3', '~> 1.3.6' # see https://github.com/rails/rails/issues/35153
+  spec.add_development_dependency 'sqlite3', '~> 1.4.2' # see https://github.com/rails/rails/issues/35153
   spec.add_development_dependency 'timecop', '~> 0.8.1'
 end

data/lib/hyper-operation.rb

@@ -28,6 +28,7 @@ if RUBY_ENGINE == 'opal'
   require 'hyper-operation/railway/validations'
   require 'hyper-operation/server_op'
   require 'hyper-operation/boot'
+  require 'hyper-operation/async_sleep'
 else
   require 'tty-table'
   require 'hyperstack-config'
@@ -45,7 +46,7 @@ else
   require 'hyper-operation/transport/client_drivers'
   require 'hyper-operation/transport/acting_user'
   require 'opal-activesupport'
-  require 'hyper-operation/delay_and_interval'
+  require 'hyper-operation/async_sleep'
   require 'hyper-operation/exception'
   require 'hyper-operation/promise'
   require 'hyper-operation/railway'

data/lib/hyper-operation/api.rb

@@ -46,8 +46,12 @@ module Hyperstack
           @_railway.process_params(args)
           @_railway.process_validations
           @_railway.run
-          @_railway.dispatch
-          @_railway.result
+          # return the result from dispatch in case there is an error
+          if (dispatch_result = @_railway.dispatch).rejected?
+            dispatch_result
+          else
+            @_railway.result
+          end
         end
       end
 

data/lib/hyper-operation/async_sleep.rb

@@ -0,0 +1,23 @@
+module Hyperstack
+  module AsyncSleep
+    if RUBY_ENGINE == 'opal'
+      def self.every(*args, &block)
+        every(*args, &block)
+      end
+
+      def self.after(*args, &block)
+        after(*args, &block)
+      end
+    else
+      extend self
+
+      def every(time, &block)
+        Thread.new { loop { sleep time; block.call } }
+      end
+
+      def after(time, &block)
+        Thread.new { sleep time; block.call }
+      end
+    end
+  end
+end

data/lib/hyper-operation/railway/dispatcher.rb

@@ -1,7 +1,6 @@
 module Hyperstack
   class Operation
     class Railway
-
       def receivers
         self.class.receivers
       end

data/lib/hyper-operation/railway/run.rb

@@ -4,10 +4,13 @@ module Hyperstack
     class Exit < StandardError
       attr_reader :state
       attr_reader :result
-      def initialize(state, result)
+      def initialize(state, result = nil)
         @state = state
         @result = result
       end
+      def to_s
+        @state
+      end
     end
 
     class Railway

data/lib/hyper-operation/server_op.rb

@@ -13,7 +13,7 @@ module Hyperstack
             hash = serialize_params(hash)
             Hyperstack::HTTP.post(
               "#{`window.HyperstackEnginePath`}/execute_remote",
-              payload: {json: {operation: name, params: hash}.to_json},
+              payload: {hyperstack_secured_json: {operation: name, params: hash}.to_json},
               headers: headers.merge('X-CSRF-Token' => Hyperstack::ClientDrivers.opts[:form_authenticity_token])
               )
             .then do |response|

data/lib/hyper-operation/transport/client_drivers.rb

@@ -97,7 +97,7 @@ module Hyperstack
           %x{
             var channel = #{ClientDrivers.opts[:pusher_api]}.subscribe(#{channel.gsub('::', '==')});
             channel.bind('dispatch', #{ClientDrivers.opts[:dispatch]})
-            channel.bind('pusher:subscription_succeeded', #{lambda {ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
+            channel.bind('pusher:subscription_succeeded', #{->(*) { ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
           }
           @pusher_dispatcher_registered = true
         elsif ClientDrivers.opts[:transport] == :action_cable
@@ -169,7 +169,7 @@ module Hyperstack
       config_hash = {
         transport: Hyperstack.transport,
         id: id,
-        acting_user_id: (controller.acting_user && controller.acting_user.id),
+        acting_user_id: (controller.acting_user.respond_to?(:id) && controller.acting_user.id),
         env: ::Rails.env,
         client_logging: Hyperstack.client_logging,
         pusher_fake_js: pusher_fake_js,

data/lib/hyper-operation/transport/connection.rb

@@ -1,173 +1,95 @@
-module Hyperstack
-  module AutoCreate
-    def table_exists?
-      # works with both rails 4 and 5 without deprecation warnings
-      if connection.respond_to?(:data_sources)
-        connection.data_sources.include?(table_name)
-      else
-        connection.tables.include?(table_name)
-      end
-    end
-
-    def needs_init?
-      Hyperstack.transport != :none && Hyperstack.on_server? && !table_exists?
-    end
-
-    def create_table(*args, &block)
-      connection.create_table(table_name, *args, &block) if needs_init?
-    end
-  end
-
-  class Connection < ActiveRecord::Base
-    class QueuedMessage < ActiveRecord::Base
-
-      extend AutoCreate
-
-      self.table_name = 'hyperstack_queued_messages'
-
-      do_not_synchronize
-
-      serialize :data
+# frozen_string_literal: true
 
-      belongs_to :hyperstack_connection,
-                 class_name: 'Hyperstack::Connection',
-                 foreign_key: 'connection_id'
-
-      scope :for_session,
-            ->(session) { joins(:hyperstack_connection).where('session = ?', session) }
-
-      # For simplicity we use QueuedMessage with connection_id 0
-      # to store the current path which is used by consoles to
-      # communicate back to the server
-
-      default_scope { where('connection_id IS NULL OR connection_id != 0') }
+module Hyperstack
+  class Connection
+    class << self
+      attr_accessor :transport, :connection_adapter, :show_diagnostics
+
+      def adapter
+        adapter_name = Hyperstack.connection[:adapter].to_s
+        adapter_path = "hyper-operation/transport/connection_adapter/#{adapter_name}"
+
+        begin
+          require adapter_path
+        rescue LoadError => e
+          if e.path == adapter_path
+            raise e.class, "Could not load the '#{adapter_name}' adapter. Make sure the adapter is spelled correctly in your Hyperstack config, and the necessary gems are in your Gemfile.", e.backtrace
+
+          # Bubbled up from the adapter require. Prefix the exception message
+          # with some guidance about how to address it and reraise.
+          else
+            raise e.class, "Error loading the '#{adapter_name}' adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+          end
+        end
 
-      def self.root_path=(path)
-        unscoped.find_or_create_by(connection_id: 0).update(data: path)
+        adapter_name = adapter_name.camelize
+        "Hyperstack::ConnectionAdapter::#{adapter_name}".constantize
       end
 
-      def self.root_path
-        unscoped.find_or_create_by(connection_id: 0).data
+      def build_tables
+        adapter.build_tables
       end
-    end
-
-    extend AutoCreate
 
-    def self.build_tables
-      create_table(force: :cascade) do |t|
-        t.string   :channel
-        t.string   :session
-        t.datetime :created_at
-        t.datetime :expires_at
-        t.datetime :refresh_at
-      end
-      QueuedMessage.create_table(force: :cascade) do |t|
-        t.text    :data
-        t.integer :connection_id
+      def build_tables?
+        adapter.respond_to?(:build_tables)
       end
-    end
-
-    do_not_synchronize
-
-    self.table_name = 'hyperstack_connections'
-
-    has_many :messages,
-             foreign_key: 'connection_id',
-             class_name: 'Hyperstack::Connection::QueuedMessage',
-             dependent: :destroy
-    scope :expired,
-          -> { where('expires_at IS NOT NULL AND expires_at < ?', Time.zone.now) }
-    scope :pending_for,
-          ->(channel) { where(channel: channel).where('session IS NOT NULL') }
-    scope :inactive,
-          -> { where('session IS NULL AND refresh_at < ?', Time.zone.now) }
-
-    def self.needs_refresh?
-      exists?(['refresh_at IS NOT NULL AND refresh_at < ?', Time.zone.now])
-    end
-
-    def transport
-      self.class.transport
-    end
-
-    before_create do
-      if session
-        self.expires_at = Time.now + transport.expire_new_connection_in
-      elsif transport.refresh_channels_every != :never
-        self.refresh_at = Time.now + transport.refresh_channels_every
-      end
-    end
-
-    class << self
-      attr_accessor :transport
 
       def active
-        # if table doesn't exist then we are either calling from within
-        # a migration or from a console before the server has ever started
-        # in these cases there are no channels so we return nothing
-        return [] unless table_exists?
-        if Hyperstack.on_server?
-          expired.delete_all
-          refresh_connections if needs_refresh?
-        end
-        all.pluck(:channel).uniq
+        adapter.active
       end
 
       def open(channel, session = nil, root_path = nil)
-        self.root_path = root_path
-        find_or_create_by(channel: channel, session: session)
+        puts "open(#{channel}, #{session}, #{root_path})" if show_diagnostics
+
+        adapter.open(channel, session, root_path).tap do |c|
+          puts " - open returning #{c}" if show_diagnostics
+        end
       end
 
       def send_to_channel(channel, data)
-        pending_for(channel).each do |connection|
-          QueuedMessage.create(data: data, hyperstack_connection: connection)
-        end
-        transport.send_data(channel, data) if exists?(channel: channel, session: nil)
+        puts "send_to_channel(#{channel}, #{data})" if show_diagnostics
+
+        adapter.send_to_channel(channel, data)
       end
 
       def read(session, root_path)
-        self.root_path = root_path
-        where(session: session)
-          .update_all(expires_at: Time.now + transport.expire_polled_connection_in)
-        QueuedMessage.for_session(session).destroy_all.pluck(:data)
+        puts "read(#{session}, #{root_path})" if show_diagnostics
+
+        adapter.read(session, root_path)
       end
 
       def connect_to_transport(channel, session, root_path)
-        self.root_path = root_path
-        if (connection = find_by(channel: channel, session: session))
-          messages = connection.messages.pluck(:data)
-          connection.destroy
-        else
-          messages = []
-        end
-        open(channel)
-        messages
+        puts "connect_to_transport(#{channel}, #{session}, #{root_path})" if show_diagnostics
+
+        adapter.connect_to_transport(channel, session, root_path)
       end
 
       def disconnect(channel)
-        find_by(channel: channel, session: nil).destroy
+        adapter.disconnect(channel)
       end
 
       def root_path=(path)
-        QueuedMessage.root_path = path if path
+        adapter.root_path = path
       end
 
       def root_path
-        # if the QueuedMessage table doesn't exist then we are either calling from within
-        # a migration or from a console before the server has ever started
-        # in these cases there is no root path to the server
-        QueuedMessage.root_path if QueuedMessage.table_exists?
+        adapter.root_path
       end
 
       def refresh_connections
-        refresh_started_at = Time.zone.now
-        channels = transport.refresh_channels
-        next_refresh = refresh_started_at + transport.refresh_channels_every
-        channels.each do |channel|
-          connection = find_by(channel: channel, session: nil)
-          connection.update(refresh_at: next_refresh) if connection
+        adapter.refresh_connections
+      end
+
+      def method_missing(method_name, *args, &block)
+        if adapter::Connection.respond_to?(method_name)
+          adapter::Connection.send(method_name, *args, &block)
+        else
+          super
         end
-        inactive.delete_all
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        adapter::Connection.respond_to?(method_name)
       end
     end
   end

data/lib/hyper-operation/transport/connection_adapter/active_record.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'active_record/connection'
+require_relative 'active_record/queued_message'
+
+module Hyperstack
+  module ConnectionAdapter
+    module ActiveRecord
+      class << self
+        def build_tables
+          Connection.create_table(force: :cascade) do |t|
+            t.string   :channel
+            t.string   :session
+            t.datetime :created_at
+            t.datetime :expires_at
+            t.datetime :refresh_at
+          end
+
+          QueuedMessage.create_table(force: :cascade) do |t|
+            t.text    :data
+            t.integer :connection_id
+          end
+        end
+
+        def transport
+          Hyperstack::Connection.transport
+        end
+
+        def active
+          # if table doesn't exist then we are either calling from within
+          # a migration or from a console before the server has ever started
+          # in these cases there are no channels so we return nothing
+          return [] unless Connection.table_exists?
+
+          if Hyperstack.on_server?
+            Connection.expired.delete_all
+            refresh_connections if Connection.needs_refresh?
+          end
+
+          Connection.all.pluck(:channel).uniq
+        rescue ::ActiveRecord::StatementInvalid
+          []
+        end
+
+        def open(channel, session = nil, root_path = nil)
+          self.root_path = root_path
+
+          Connection.find_or_create_by(channel: channel, session: session)
+        end
+
+        def send_to_channel(channel, data)
+          Connection.pending_for(channel).each do |connection|
+            QueuedMessage.create(data: data, hyperstack_connection: connection)
+          end
+
+          transport.send_data(channel, data) if Connection.exists?(channel: channel, session: nil)
+        end
+
+        def read(session, root_path)
+          self.root_path = root_path
+
+          Connection.where(session: session)
+                    .update_all(expires_at: Time.current + transport.expire_polled_connection_in)
+
+          QueuedMessage.for_session(session).destroy_all.pluck(:data)
+        end
+
+        def connect_to_transport(channel, session, root_path)
+          self.root_path = root_path
+
+          if (connection = Connection.find_by(channel: channel, session: session))
+            messages = connection.messages.pluck(:data)
+            connection.destroy
+          else
+            messages = []
+          end
+
+          open(channel)
+
+          messages
+        end
+
+        def disconnect(channel)
+          Connection.find_by(channel: channel, session: nil).destroy
+        end
+
+        def root_path=(path)
+          QueuedMessage.root_path = path if path
+        end
+
+        def root_path
+          # if the QueuedMessage table doesn't exist then we are either calling from within
+          # a migration or from a console before the server has ever started
+          # in these cases there is no root path to the server
+          QueuedMessage.root_path if QueuedMessage.table_exists?
+        end
+
+        def refresh_connections
+          refresh_started_at = Time.current
+          channels = transport.refresh_channels
+          next_refresh = refresh_started_at + transport.refresh_channels_every
+
+          channels.each do |channel|
+            connection = Connection.find_by(channel: channel, session: nil)
+            connection.update(refresh_at: next_refresh) if connection
+          end
+
+          Connection.inactive.delete_all
+        end
+      end
+    end
+  end
+end