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

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

@@ -1,4 +1,4 @@
-module Hyperstack
+module Hyperloop
   module AutoCreate
     def table_exists?
       # works with both rails 4 and 5 without deprecation warnings
@@ -10,7 +10,7 @@ module Hyperstack
     end
 
     def needs_init?
-      Hyperstack.transport != :none && Hyperstack.on_server? && !table_exists?
+      Hyperloop.transport != :none && Hyperloop.on_server? && !table_exists?
     end
 
     def create_table(*args, &block)
@@ -23,18 +23,18 @@ module Hyperstack
 
       extend AutoCreate
 
-      self.table_name = 'hyperstack_queued_messages'
+      self.table_name = 'hyperloop_queued_messages'
 
       do_not_synchronize
 
       serialize :data
 
-      belongs_to :hyperstack_connection,
-                 class_name: 'Hyperstack::Connection',
+      belongs_to :hyperloop_connection,
+                 class_name: 'Hyperloop::Connection',
                  foreign_key: 'connection_id'
 
       scope :for_session,
-            ->(session) { joins(:hyperstack_connection).where('session = ?', 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
@@ -69,11 +69,11 @@ module Hyperstack
 
     do_not_synchronize
 
-    self.table_name = 'hyperstack_connections'
+    self.table_name = 'hyperloop_connections'
 
     has_many :messages,
              foreign_key: 'connection_id',
-             class_name: 'Hyperstack::Connection::QueuedMessage',
+             class_name: 'Hyperloop::Connection::QueuedMessage',
              dependent: :destroy
     scope :expired,
           -> { where('expires_at IS NOT NULL AND expires_at < ?', Time.zone.now) }
@@ -106,7 +106,7 @@ module Hyperstack
         # 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?
+        if Hyperloop.on_server?
           expired.delete_all
           refresh_connections if needs_refresh?
         end
@@ -120,7 +120,7 @@ module Hyperstack
 
       def send_to_channel(channel, data)
         pending_for(channel).each do |connection|
-          QueuedMessage.create(data: data, hyperstack_connection: connection)
+          QueuedMessage.create(data: data, hyperloop_connection: connection)
         end
         transport.send_data(channel, data) if exists?(channel: channel, session: nil)
       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,9 +13,9 @@ 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.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
@@ -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,18 +49,16 @@ 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
@@ -109,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
 
@@ -117,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
 
@@ -165,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
@@ -14,15 +14,15 @@ module Hyperstack
     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
@@ -30,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]
 
@@ -39,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
@@ -101,43 +101,41 @@ 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
@@ -153,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
@@ -171,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

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

@@ -1,18 +1,8 @@
-module Hyperstack
+module Hyperloop
 
   class InternalClassPolicy
 
     def initialize(regulated_klass)
-      unless regulated_klass.is_a?(Class)
-        # attempt to constantize the class in case eager_loading in production
-        # has loaded the policy before the class.  THis will insure that if
-        # there is a class being regulated, it is loaded first.
-        begin
-          regulated_klass.constantize
-        rescue NameError
-          nil
-        end
-      end
       @regulated_klass = regulated_klass
     end
 
@@ -21,7 +11,7 @@ module Hyperstack
     EXPOSED_METHODS = [
       :regulate_class_connection, :always_allow_connection, :regulate_instance_connections,
       :regulate_all_broadcasts, :regulate_broadcast,
-      :regulate_dispatches_from, :always_dispatch_from,
+      :dispatch_to, :regulate_dispatches_from, :always_dispatch_from,
       :allow_change, :allow_create, :allow_read, :allow_update, :allow_destroy
     ]
 
@@ -58,6 +48,21 @@ module Hyperstack
       regulate_dispatches_from(*args) { true }
     end
 
+    def dispatch_to(*args, &regulation)
+      actual_klass = if regulated_klass.is_a?(Class)
+                       regulated_klass
+                     else
+                       begin
+                         regulated_klass.constantize
+                       rescue NameError
+                         nil
+                       end
+                     end
+      raise 'you can only dispatch_to Operation classes' unless actual_klass.respond_to? :dispatch_to
+      actual_klass.dispatch_to(actual_klass)
+      actual_klass.dispatch_to(*args, &regulation)
+    end
+
     CHANGE_POLICIES = [:create, :update, :destroy]
 
     def self.allow_policy(policy, method)
@@ -90,7 +95,7 @@ module Hyperstack
     def get_ar_model(str)
       if str.is_a?(Class)
         unless str <= ActiveRecord::Base
-          Hyperstack::InternalPolicy.raise_operation_access_violation(:non_ar_class, "#{str} is not a subclass of ActiveRecord::Base")
+          Hyperloop::InternalPolicy.raise_operation_access_violation
         end
         str
       else
@@ -99,12 +104,12 @@ module Hyperstack
         # def self.ar_base_descendants_map_cache
         #   @ar_base_descendants_map_cache ||= ActiveRecord::Base.descendants.map(&:name)
         # end
-        # if Rails.env.production? && !Hyperstack::InternalClassPolicy.ar_base_descendants_map_cache.include?(str)
+        # if Rails.env.production? && !Hyperloop::InternalClassPolicy.ar_base_descendants_map_cache.include?(str)
         if Rails.application.config.eager_load && !ActiveRecord::Base.descendants.map(&:name).include?(str)
           # AR::Base.descendants is eager loaded in production -> this guard works.
           # In development it may be empty or partially filled -> this guard may fail.
           # Thus guarded here only in production.
-          Hyperstack::InternalPolicy.raise_operation_access_violation(:non_ar_class, "#{str} is either not defined or is not a subclass of ActiveRecord::Base")
+          Hyperloop::InternalPolicy.raise_operation_access_violation
         end
         Object.const_get(str)
       end
@@ -187,7 +192,7 @@ module Hyperstack
           raise "Could not determine the class when regulating.  This is probably caused by doing something like &:send_all"
         end
         wrapped_policy = policy_klass.new(nil, nil)
-        wrapped_policy.hyperstack_internal_policy_object = policy
+        wrapped_policy.hyperloop_internal_policy_object = policy
         wrapped_policy
       end
 
@@ -338,7 +343,7 @@ module Hyperstack
     def self.channels(session, acting_user)
       channels = ClassConnectionRegulation.connections_for(acting_user, true) +
         InstanceConnectionRegulation.connections_for(acting_user, true)
-      channels << "Hyperstack::Session-#{session.split('-').last}" if Hyperstack.connect_session && session
+      channels << "Hyperloop::Session-#{session.split('-').last}" if Hyperloop.connect_session && session
       channels.uniq.each { |channel| Connection.open(channel, session) }
     end
   end
@@ -363,16 +368,16 @@ module Hyperstack
       @obj
     end
 
-    def self.raise_operation_access_violation(message, details)
-      raise Hyperstack::AccessViolation.new(message, details)
+    def self.raise_operation_access_violation
+      raise Hyperloop::AccessViolation
     end
 
     def self.regulate_connection(acting_user, channel_string)
       channel = channel_string.split("-")
       if channel.length > 1
         id = channel[1..-1].join("-")
-        unless Hyperstack::InternalClassPolicy.regulated_klasses.include?(channel[0])
-          Hyperstack::InternalPolicy.raise_operation_access_violation(:not_a_channel, "#{channel[0]} is not regulated channel class")
+        unless Hyperloop::InternalClassPolicy.regulated_klasses.include?(channel[0])
+          Hyperloop::InternalPolicy.raise_operation_access_violation
         end
         object = Object.const_get(channel[0]).find(id)
         InstanceConnectionRegulation.connect(object, acting_user)
@@ -390,17 +395,16 @@ module Hyperstack
       internal_policy.broadcast &block
     end
 
-    def initialize(obj, attribute_names, available_channels = :all)
+    def initialize(obj, attribute_names, available_channels)
       @obj = obj
-      @attribute_names = attribute_names.map(&:to_sym).to_set
+      attribute_names = attribute_names.map(&:to_sym).to_set
       @unassigned_send_sets = []
-      @channel_sets = Hash.new { |hash, key| hash[key] = @attribute_names }
+      @channel_sets = Hash.new { |hash, key| hash[key] = attribute_names }
       @available_channels = available_channels
     end
 
     def channel_available?(channel)
-      return false unless channel
-      @available_channels == :all || @available_channels.include?(channel_to_string(channel))
+      channel && @available_channels.include?(channel_to_string(channel))
     end
 
     def id
@@ -508,12 +512,12 @@ module Hyperstack
   end
 
   module ClassPolicyMethods
-    def hyperstack_internal_policy_object
-      @hyperstack_internal_policy_object ||= InternalClassPolicy.new(name || self)
+    def hyperloop_internal_policy_object
+      @hyperloop_internal_policy_object ||= InternalClassPolicy.new(name || self)
     end
     InternalClassPolicy::EXPOSED_METHODS.each do |policy_method|
       define_method policy_method do |*klasses, &block|
-        hyperstack_internal_policy_object.send policy_method, *klasses, &block
+        hyperloop_internal_policy_object.send policy_method, *klasses, &block
       end unless respond_to? policy_method
     end
   end
@@ -524,10 +528,10 @@ module Hyperstack
         extend ClassPolicyMethods
       end
     end
-    attr_accessor :hyperstack_internal_policy_object
+    attr_accessor :hyperloop_internal_policy_object
     InternalPolicy::EXPOSED_METHODS.each do |method|
       define_method method do |*args, &block|
-        hyperstack_internal_policy_object.send method, *args, &block
+        hyperloop_internal_policy_object.send method, *args, &block
       end unless respond_to? method
     end
     define_method :initialize do |*args|
@@ -544,34 +548,34 @@ module Hyperstack
 end
 
 class Module
-  alias pre_hyperstack_const_set const_set
+  alias pre_hyperloop_const_set const_set
 
   def const_set(name, value)
-    pre_hyperstack_const_set(name, value).tap do
-      Hyperstack::PolicyAutoLoader.load(name, value)
+    pre_hyperloop_const_set(name, value).tap do
+      Hyperloop::PolicyAutoLoader.load(name, value)
     end
   end
 end
 
 class Class
 
-  alias pre_hyperstack_inherited inherited
+  alias pre_hyperloop_inherited inherited
 
   def inherited(child_class)
-    pre_hyperstack_inherited(child_class).tap do
-      Hyperstack::PolicyAutoLoader.load(child_class.name, child_class)
+    pre_hyperloop_inherited(child_class).tap do
+      Hyperloop::PolicyAutoLoader.load(child_class.name, child_class)
     end
   end
 
-  Hyperstack::ClassPolicyMethods.instance_methods.each do |method|
+  Hyperloop::ClassPolicyMethods.instance_methods.each do |method|
     define_method method do |*args, &block|
       if name.end_with?("Policy".freeze)
-        @hyperstack_internal_policy_object = Hyperstack::InternalClassPolicy.new(name.sub(/Policy$/,""))
-        include Hyperstack::PolicyMethods
+        @hyperloop_internal_policy_object = Hyperloop::InternalClassPolicy.new(name.sub(/Policy$/,""))
+        include Hyperloop::PolicyMethods
         send method, *args, &block
       else
         class << self
-          Hyperstack::ClassPolicyMethods.instance_methods.each do |method|
+          Hyperloop::ClassPolicyMethods.instance_methods.each do |method|
             undef_method method
           end
         end