hyper-operation 1.0.alpha1.8 → 1.0.0.lap28

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

@@ -1,95 +1,173 @@
-# frozen_string_literal: true
+module Hyperloop
+  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
 
-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 needs_init?
+      Hyperloop.transport != :none && Hyperloop.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 = 'hyperloop_queued_messages'
+
+      do_not_synchronize
 
-        adapter_name = adapter_name.camelize
-        "Hyperstack::ConnectionAdapter::#{adapter_name}".constantize
+      serialize :data
+
+      belongs_to :hyperloop_connection,
+                 class_name: 'Hyperloop::Connection',
+                 foreign_key: 'connection_id'
+
+      scope :for_session,
+            ->(session) { joins(:hyperloop_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') }
+
+      def self.root_path=(path)
+        unscoped.find_or_create_by(connection_id: 0).update(data: path)
       end
 
-      def build_tables
-        adapter.build_tables
+      def self.root_path
+        unscoped.find_or_create_by(connection_id: 0).data
       end
+    end
 
-      def build_tables?
-        adapter.respond_to?(:build_tables)
+    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
       end
+    end
 
-      def active
-        adapter.active
+    do_not_synchronize
+
+    self.table_name = 'hyperloop_connections'
+
+    has_many :messages,
+             foreign_key: 'connection_id',
+             class_name: 'Hyperloop::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
 
-      def open(channel, session = nil, root_path = nil)
-        puts "open(#{channel}, #{session}, #{root_path})" if show_diagnostics
+    class << self
+      attr_accessor :transport
 
-        adapter.open(channel, session, root_path).tap do |c|
-          puts " - open returning #{c}" if show_diagnostics
+      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 Hyperloop.on_server?
+          expired.delete_all
+          refresh_connections if needs_refresh?
         end
+        all.pluck(:channel).uniq
       end
 
-      def send_to_channel(channel, data)
-        puts "send_to_channel(#{channel}, #{data})" if show_diagnostics
+      def open(channel, session = nil, root_path = nil)
+        self.root_path = root_path
+        find_or_create_by(channel: channel, session: session)
+      end
 
-        adapter.send_to_channel(channel, data)
+      def send_to_channel(channel, data)
+        pending_for(channel).each do |connection|
+          QueuedMessage.create(data: data, hyperloop_connection: connection)
+        end
+        transport.send_data(channel, data) if exists?(channel: channel, session: nil)
       end
 
       def read(session, root_path)
-        puts "read(#{session}, #{root_path})" if show_diagnostics
-
-        adapter.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)
       end
 
       def connect_to_transport(channel, session, root_path)
-        puts "connect_to_transport(#{channel}, #{session}, #{root_path})" if show_diagnostics
-
-        adapter.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
       end
 
       def disconnect(channel)
-        adapter.disconnect(channel)
+        find_by(channel: channel, session: nil).destroy
       end
 
       def root_path=(path)
-        adapter.root_path = path
+        QueuedMessage.root_path = path if path
       end
 
       def root_path
-        adapter.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
-        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
+        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
         end
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        adapter::Connection.respond_to?(method_name)
+        inactive.delete_all
       end
     end
   end

data/lib/hyper-operation/transport/{hyperstack.rb → hyperloop.rb}

@@ -1,6 +1,6 @@
 # Provides the configuration and the two basic routines for the server
 # to indicate that records have changed: after_change and after_destroy
-module Hyperstack
+module Hyperloop
 
   def self.initialize_policies
     reset_operations unless @config_reset_called
@@ -13,10 +13,10 @@ module Hyperstack
   def self.reset_operations
     @config_reset_called = true
     Rails.configuration.tap do |config|
-      # config.eager_load_paths += %W(#{config.root}/app/hyperstack/models)
-      # config.autoload_paths += %W(#{config.root}/app/hyperstack/models)
-      # config.assets.paths << ::Rails.root.join('app', 'hyperstack').to_s
-      config.after_initialize { Connection.build_tables if Connection.build_tables? }
+      # config.eager_load_paths += %W(#{config.root}/app/hyperloop/models)
+      # config.autoload_paths += %W(#{config.root}/app/hyperloop/models)
+      # config.assets.paths << ::Rails.root.join('app', 'hyperloop').to_s
+      config.after_initialize { Connection.build_tables }
     end
     Object.send(:remove_const, :Application) if @fake_application_defined
     @fake_application_defined = false
@@ -37,10 +37,10 @@ module Hyperstack
       @fake_application_defined = true
     end
     begin
-      Object.const_get 'Hyperstack::ApplicationPolicy'
+      Object.const_get 'Hyperloop::ApplicationPolicy'
     rescue LoadError
     rescue NameError => e
-      raise e unless e.message =~ /uninitialized constant Hyperstack::ApplicationPolicy/
+      raise e unless e.message =~ /uninitialized constant Hyperloop::ApplicationPolicy/
     end
     @pusher = nil
   end
@@ -49,31 +49,21 @@ module Hyperstack
     if transport == :action_cable
       require 'hyper-operation/transport/action_cable'
       opts[:refresh_channels_every] = :never
-      import 'action_cable', client_only: true if Rails.configuration.hyperstack.auto_config
+      import 'action_cable', client_only: true if Rails.configuration.hyperloop.auto_config
     elsif transport == :pusher
       require 'pusher'
-      import 'hyperstack/pusher', client_only: true if Rails.configuration.hyperstack.auto_config
+      import 'hyperloop/pusher', client_only: true if Rails.configuration.hyperloop.auto_config
       opts[:refresh_channels_every] = nil if opts[:refresh_channels_every] == :never
     else
       opts[:refresh_channels_every] = nil if opts[:refresh_channels_every] == :never
     end
   end
 
-  define_setting(:send_to_server_timeout, 10)
-
   define_setting :opts, {}
   define_setting :channel_prefix, 'synchromesh'
   define_setting :client_logging, true
   define_setting :connect_session, true
 
-  define_setting(:connection, { adapter: :active_record }) do |connection|
-    if connection[:adapter] == :redis
-      require 'redis'
-
-      connection[:redis_url] ||= 'redis://127.0.0.1:6379/hyperstack'
-    end
-  end
-
   def self.app_id
     opts[:app_id] || Pusher.app_id if transport == :pusher
   end
@@ -117,7 +107,7 @@ module Hyperstack
 
   def self.refresh_channels
     new_channels = pusher.channels[:channels].collect do |channel, _etc|
-      channel.gsub(/^#{Regexp.quote(Hyperstack.channel)}\-/, '').gsub('==', '::')
+      channel.gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/, '').gsub('==', '::')
     end
   end
 
@@ -125,9 +115,9 @@ module Hyperstack
     if !on_server?
       send_to_server(channel, data)
     elsif transport == :pusher
-      pusher.trigger("#{Hyperstack.channel}-#{data[1][:channel].gsub('::', '==')}", *data)
+      pusher.trigger("#{Hyperloop.channel}-#{data[1][:channel].gsub('::', '==')}", *data)
     elsif transport == :action_cable
-      ActionCable.server.broadcast("hyperstack-#{channel}", message: data[0], data: data[1])
+      ActionCable.server.broadcast("hyperloop-#{channel}", message: data[0], data: data[1])
     end
   end
 
@@ -173,15 +163,12 @@ module Hyperstack
     request.body = {
       channel: channel, data: data, salt: salt, authorization: authorization
     }.to_json
-    Timeout::timeout(Hyperstack.send_to_server_timeout) { http.request(request) }
-  rescue Timeout::Error
-    puts "\n********* FAILED TO RECEIVE RESPONSE FROM SERVER WITHIN #{Hyperstack.send_to_server_timeout} SECONDS. CHANGES WILL NOT BE SYNCED ************\n"
-    raise 'no server running'
+    http.request(request)
   end
 
   def self.dispatch(data)
-    if !Hyperstack.on_server? && Connection.root_path
-      Hyperstack.send_to_server(data[:channel], [:dispatch, data])
+    if !Hyperloop.on_server? && Connection.root_path
+      Hyperloop.send_to_server(data[:channel], [:dispatch, data])
     else
       Connection.send_to_channel(data[:channel], [:dispatch, data])
     end

data/lib/hyper-operation/transport/{hyperstack_controller.rb → hyperloop_controller.rb}

@@ -1,6 +1,6 @@
-module Hyperstack
-  ::Hyperstack::Engine.routes.append do
-    Hyperstack.initialize_policies
+module Hyperloop
+  ::Hyperloop::Engine.routes.append do
+    Hyperloop.initialize_policies
 
     module ::WebConsole
       class Middleware
@@ -11,22 +11,18 @@ module Hyperstack
       end
     end if defined? ::WebConsole::Middleware
 
-
-    # The purpose of this is to prevent massive amounts of logging
-    # if using simple polling. If polling is on then only actual messages
-    # with content will be shown, other wise the log message is dropped.
     module ::Rails
       module Rack
         class Logger < ActiveSupport::LogSubscriber
-          unless method_defined? :pre_hyperstack_call
-            alias pre_hyperstack_call call
+          unless method_defined? :pre_hyperloop_call
+            alias pre_hyperloop_call call
             def call(env)
-              if Hyperstack.transport == :simple_poller && env['PATH_INFO'] && env['PATH_INFO'].include?('/hyperstack-read/')
+              if Hyperloop.transport == :simple_poller && env['PATH_INFO'] && env['PATH_INFO'].include?('/hyperloop-read/')
                 Rails.logger.silence do
-                  pre_hyperstack_call(env)
+                  pre_hyperloop_call(env)
                 end
               else
-                pre_hyperstack_call(env)
+                pre_hyperloop_call(env)
               end
             end
           end
@@ -34,7 +30,7 @@ module Hyperstack
       end
     end if defined?(::Rails::Rack::Logger)
 
-    class HyperstackController < ::ApplicationController
+    class HyperloopController < ::ApplicationController
 
       protect_from_forgery except: [:console_update, :execute_remote_api]
 
@@ -43,28 +39,28 @@ module Hyperstack
       end
 
       before_action do
-        session.delete 'hyperstack-dummy-init' unless session.id
+        session.delete 'hyperloop-dummy-init' unless session.id
       end
 
       def session_channel
-        "Hyperstack::Session-#{session.id}"
+        "Hyperloop::Session-#{session.id}"
       end
 
       def regulate(channel)
-        unless channel == session_channel # "Hyperstack::Session-#{client_id.split('-').last}"
-          Hyperstack::InternalPolicy.regulate_connection(try(:acting_user), channel)
+        unless channel == session_channel # "Hyperloop::Session-#{client_id.split('-').last}"
+          Hyperloop::InternalPolicy.regulate_connection(try(:acting_user), channel)
         end
         channel
       end
 
       def channels(user = acting_user, session_id = session.id)
-        Hyperstack::AutoConnect.channels(session_id, user)
+        Hyperloop::AutoConnect.channels(session_id, user)
       end
 
       def can_connect?(channel, user = acting_user)
-        Hyperstack::InternalPolicy.regulate_connection(
+        Hyperloop::InternalPolicy.regulate_connection(
           user,
-          Hyperstack::InternalPolicy.channel_to_string(channel)
+          Hyperloop::InternalPolicy.channel_to_string(channel)
         )
         true
       rescue
@@ -105,47 +101,45 @@ module Hyperstack
 
       def subscribe
         channel = regulate params[:channel].gsub('==', '::')
-        root_path = request.original_url.gsub(/hyperstack-subscribe.*$/, '')
-        Hyperstack::Connection.open(channel, client_id, root_path)
+        root_path = request.original_url.gsub(/hyperloop-subscribe.*$/, '')
+        Hyperloop::Connection.open(channel, client_id, root_path)
         head :ok
       rescue Exception
         head :unauthorized
       end
 
       def read
-        root_path = request.original_url.gsub(/hyperstack-read.*$/, '')
-        data = Hyperstack::Connection.read(client_id, root_path)
+        root_path = request.original_url.gsub(/hyperloop-read.*$/, '')
+        data = Hyperloop::Connection.read(client_id, root_path)
         render json: data
       end
 
       def pusher_auth
-        raise unless Hyperstack.transport == :pusher
-        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperstack.channel)}\-/,'').gsub('==', '::')
-        response = Hyperstack.pusher.authenticate(params[:channel_name], params[:socket_id])
+        raise unless Hyperloop.transport == :pusher
+        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'').gsub('==', '::')
+        response = Hyperloop.pusher.authenticate(params[:channel_name], params[:socket_id])
         render json: response
       rescue Exception => e
         head :unauthorized
       end
 
       def action_cable_auth
-        raise unless Hyperstack.transport == :action_cable
-        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperstack.channel)}\-/,'')
+        raise unless Hyperloop.transport == :action_cable
+        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'')
         salt = SecureRandom.hex
-        authorization = Hyperstack.authorization(salt, channel, client_id)
+        authorization = Hyperloop.authorization(salt, channel, client_id)
         render json: {authorization: authorization, salt: salt}
       rescue Exception
         head :unauthorized
       end
 
       def connect_to_transport
-        root_path = request.original_url.gsub(/hyperstack-connect-to-transport.*$/, '')
-        render json: Hyperstack::Connection.connect_to_transport(params[:channel], client_id, root_path)
-      rescue Exception => e
-        render status: :service_unavailable, json: {error: e}
+        root_path = request.original_url.gsub(/hyperloop-connect-to-transport.*$/, '')
+        render json: Hyperloop::Connection.connect_to_transport(params[:channel], client_id, root_path)
       end
 
       def execute_remote
-        parsed_params = JSON.parse(params[:hyperstack_secured_json]).symbolize_keys
+        parsed_params = JSON.parse(params[:json]).symbolize_keys
         render ServerOp.run_from_client(
           :acting_user,
           self,
@@ -157,15 +151,15 @@ module Hyperstack
       def execute_remote_api
         params.require(:params).permit!
         parsed_params = params[:params].to_h.symbolize_keys
-        raise AccessViolation.new(:illegal_remote_api_call) unless parsed_params[:authorization]
+        raise AccessViolation unless parsed_params[:authorization]
         render ServerOp.run_from_client(:authorization, self, params[:operation], parsed_params)
       end
 
       def console_update # TODO this should just become an execute-remote-api call
         raise unless Rails.env.development?
-        authorization = Hyperstack.authorization(params[:salt], params[:channel], params[:data][1][:broadcast_id]) #params[:data].to_json)
+        authorization = Hyperloop.authorization(params[:salt], params[:channel], params[:data][1][:broadcast_id]) #params[:data].to_json)
         return head :unauthorized if authorization != params[:authorization]
-        Hyperstack::Connection.send_to_channel(params[:channel], params[:data])
+        Hyperloop::Connection.send_to_channel(params[:channel], params[:data])
         head :no_content
       rescue
         head :unauthorized
@@ -175,32 +169,32 @@ module Hyperstack
         head :no_content
       end
 
-    end unless defined? Hyperstack::HyperstackController
+    end unless defined? Hyperloop::HyperloopController
 
     match 'execute_remote',
-          to: 'hyperstack#execute_remote', via: :post
+          to: 'hyperloop#execute_remote', via: :post
     match 'execute_remote_api',
-          to: 'hyperstack#execute_remote_api', via: :post
-
-    # match 'hyperstack-subscribe',
-    #       to: 'hyperstack#subscribe', via: :get
-    # match 'hyperstack-read/:subscriber',
-    #       to: 'hyperstack#read',      via: :get
-    match 'hyperstack-subscribe/:client_id/:channel',
-          to: 'hyperstack#subscribe', via: :get
-    match 'hyperstack-read/:client_id',
-          to: 'hyperstack#read', via: :get
-    match 'hyperstack-pusher-auth',
-          to: 'hyperstack#pusher_auth', via: :post
-    match 'hyperstack-action-cable-auth/:client_id/:channel_name',
-          to: 'hyperstack#action_cable_auth', via: :post
-    match 'hyperstack-connect-to-transport/:client_id/:channel',
-          to: 'hyperstack#connect_to_transport', via: :get
+          to: 'hyperloop#execute_remote_api', via: :post
+
+    # match 'hyperloop-subscribe',
+    #       to: 'hyperloop#subscribe', via: :get
+    # match 'hyperloop-read/:subscriber',
+    #       to: 'hyperloop#read',      via: :get
+    match 'hyperloop-subscribe/:client_id/:channel',
+          to: 'hyperloop#subscribe', via: :get
+    match 'hyperloop-read/:client_id',
+          to: 'hyperloop#read', via: :get
+    match 'hyperloop-pusher-auth',
+          to: 'hyperloop#pusher_auth', via: :post
+    match 'hyperloop-action-cable-auth/:client_id/:channel_name',
+          to: 'hyperloop#action_cable_auth', via: :post
+    match 'hyperloop-connect-to-transport/:client_id/:channel',
+          to: 'hyperloop#connect_to_transport', via: :get
     match 'console',
-          to: 'hyperstack#debug_console', via: :get
+          to: 'hyperloop#debug_console', via: :get
     match 'console_update',
-          to: 'hyperstack#console_update', via: :post
+          to: 'hyperloop#console_update', via: :post
     match 'server_up',
-          to: 'hyperstack#server_up', via: :get
+          to: 'hyperloop#server_up', via: :get
   end
 end