hyper-operation 0.5.12 → 0.99.0

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

@@ -68,6 +68,7 @@ module Hyperloop
         end
 
         def hash_filter
+          # the :duck method is added in lib/hyper-operation.rb globally
           @hash_filter ||= Mutations::HashFilter.new
         end
 

data/lib/hyper-operation/server_op.rb

@@ -1,37 +1,99 @@
+require 'net/http' unless RUBY_ENGINE == 'opal'
+
 module Hyperloop
   class ServerOp < Operation
 
     class << self
-      def run(*args)
-        hash = _Railway.params_wrapper.combine_arg_array(args)
-        hash = serialize_params(hash)
-        HTTP.post(
-          "#{`window.HyperloopEnginePath`}/execute_remote",
-          payload: {json: {operation: name, params: hash}.to_json},
-          headers: {'X-CSRF-Token' => Hyperloop::ClientDrivers.opts[:form_authenticity_token] }
-          )
-        .then do |response|
-          deserialize_response response.json[:response]
-        end.fail do |response|
-          Exception.new response.json[:error]
+      include React::IsomorphicHelpers
+
+      if RUBY_ENGINE == 'opal'
+        if on_opal_client?
+          def run(*args)
+            hash = _Railway.params_wrapper.combine_arg_array(args)
+            hash = serialize_params(hash)
+            Hyperloop::HTTP.post(
+              "#{`window.HyperloopEnginePath`}/execute_remote",
+              payload: {json: {operation: name, params: hash}.to_json},
+              headers: {'X-CSRF-Token' => Hyperloop::ClientDrivers.opts[:form_authenticity_token] }
+              )
+            .then do |response|
+              deserialize_response response.json[:response]
+            end
+            .fail do |response|
+              Exception.new response.json[:error]
+            end
+          end
+        elsif on_opal_server?
+          def run(*args)
+            promise = Promise.new
+            response = internal_iso_run(name, args)
+            if response[:json][:response]
+              promise.resolve(response[:json][:response])
+            else
+              promise.reject Exception.new response[:json][:error]
+            end
+            promise
+          end
         end
-      end if RUBY_ENGINE == 'opal'
+      end
+
+      isomorphic_method(:internal_iso_run) do |f, klass_name, op_params|
+        f.send_to_server(klass_name, op_params)
+        f.when_on_server {
+          Hyperloop::ServerOp.run_from_client(:acting_user, controller, klass_name, *op_params)
+        }
+      end
+
+      def descendants_map_cache
+        # calling descendants alone may take 10ms in a complex app, so better cache it
+        @cached_descendants ||= Hyperloop::ServerOp.descendants.map(&:to_s)
+      end
 
       def run_from_client(security_param, controller, operation, params)
+        if Rails.env.production?
+          # in production everything is eager loaded so ServerOp.descendants is filled and can be used to guard the .constantize
+          unless Hyperloop::ServerOp.descendants_map_cache.include?(operation)
+            Hyperloop::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (in production)")
+          end
+          # however ...
+        else
+          # ... in development things are autoloaded on demand, thus ServerOp.descendants can be empty or partially filled and above guard
+          # would fail legal operations. To prevent this, the class has to be loaded first, what .const_get will take care of, and then
+          # its guarded, to achieve similar behaviour as in production. Doing the const_get first, before the guard,
+          # would not be safe for production and allow for potential remote code execution!
+          begin
+            const = Object.const_get(operation)
+          rescue NameError
+            Hyperloop::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (const not found)")
+          end
+          unless const < Hyperloop::ServerOp
+            Hyperloop::InternalPolicy.raise_operation_access_violation(:illegal_remote_op_call, "Operation: #{operation} (not a ServerOp subclass)")
+          end
+        end
         operation.constantize.class_eval do
           if _Railway.params_wrapper.method_defined?(:controller)
             params[:controller] = controller
           elsif !_Railway.params_wrapper.method_defined?(security_param)
             raise AccessViolation
           end
-          run(params)
+          run(deserialize_params(params))
           .then { |r| return { json: { response: serialize_response(r) } } }
-          .fail { |e| return { json: { error: e }, status: 500 } }
+          .fail { |e| return handle_exception(e, operation, params) }
         end
       rescue Exception => e
-        { json: {error: e}, status: 500 }
+        handle_exception(e, operation, params)
       end
 
+      def handle_exception(e, operation, params)
+        if defined? ::Rails
+          params.delete(:controller)
+          ::Rails.logger.debug "\033[0;31;1mERROR: Hyperloop::ServerOp exception caught when running "\
+                               "#{operation} with params \"#{params}\": #{e}\033[0;30;21m"
+        end
+        { json: { error: e }, status: 500 }
+      end
+
+
       def remote(path, *args)
         promise = Promise.new
         uri = URI("#{path}execute_remote_api")
@@ -39,7 +101,6 @@ module Hyperloop
         request = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
         if uri.scheme == 'https'
           http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         end
         request.body = {
           operation: name,
@@ -86,9 +147,13 @@ module Hyperloop
         end
         regulation ||= proc { args }
         on_dispatch do |params, operation|
+          operation.instance_variable_set(:@_dispatched_channels, []) unless operation.instance_variable_get(:@_dispatched_channels)
           serialized_params = serialize_dispatch(params.to_h)
           [operation.instance_exec(*context, &regulation)].flatten.compact.uniq.each do |channel|
-            Hyperloop.dispatch(channel: Hyperloop::InternalPolicy.channel_to_string(channel), operation: operation.class.name, params: serialized_params)
+            unless operation.instance_variable_get(:@_dispatched_channels).include?(channel)
+              operation.instance_variable_set(:@_dispatched_channels, operation.instance_variable_get(:@_dispatched_channels) << channel)
+              Hyperloop.dispatch(channel: Hyperloop::InternalPolicy.channel_to_string(channel), operation: operation.class.name, params: serialized_params)
+            end
           end
         end
       end if RUBY_ENGINE != 'opal'

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

@@ -7,8 +7,25 @@ module Hyperloop
   # client interface to sync_change or sync_destroy
 
   class Application
-    def self.acting_user_id
-      ClientDrivers.opts[:acting_user_id]
+    extend React::IsomorphicHelpers::ClassMethods
+
+    if on_opal_client?
+      def self.acting_user_id
+        ClientDrivers.opts[:acting_user_id]
+      end
+    else
+      def self.acting_user_id
+        ClientDrivers.client_drivers_get_acting_user_id
+      end
+    end
+
+    def self.env
+      @env = ClientDrivers.env unless @env
+      @env
+    end
+
+    def self.production?
+      env == 'production'
     end
   end
 
@@ -59,8 +76,9 @@ module Hyperloop
           }
         elsif ClientDrivers.opts[:transport] == :action_cable
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
-          HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel)).then do |response|
+          Hyperloop::HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel), headers: { 'X-CSRF-Token' => ClientDrivers.opts[:form_authenticity_token] }).then do |response|
             %x{
+              var fix_opal_0110 = 'return';
               #{Hyperloop.action_cable_consumer}.subscriptions.create(
                 {
                   channel: "Hyperloop::ActionCableChannel",
@@ -71,9 +89,11 @@ module Hyperloop
                 },
                 {
                   connected: function() {
-                    #{ClientDrivers.get_queued_data("connect-to-transport", channel_string)}
+                    if (#{ClientDrivers.env == 'development'}) { console.log("ActionCable connected to: ", channel_string); }
+                    #{ClientDrivers.complete_connection(channel_string)}
                   },
                   received: function(data) {
+                    if (#{ClientDrivers.env == 'development'}) { console.log("ActionCable received: ", data); }
                     #{ClientDrivers.sync_dispatch(JSON.parse(`JSON.stringify(data)`)['data'])}
                   }
                 }
@@ -81,7 +101,7 @@ module Hyperloop
             }
           end
         else
-          HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
+          Hyperloop::HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
         end
       end
     end
@@ -105,24 +125,26 @@ module Hyperloop
     # will remove the session from the list.
 
     prerender_footer do |controller|
-      next if Hyperloop.transport == :none
-      if defined?(PusherFake)
-        path = ::Rails.application.routes.routes.detect do |route|
-          route.app == Hyperloop::Engine ||
-            (route.app.respond_to?(:app) && route.app.app == Hyperloop::Engine)
-        end.path.spec
-        pusher_fake_js = PusherFake.javascript(
-          auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
-          authEndpoint: "#{path}/hyperloop-pusher-auth"
-        )
+      unless Hyperloop.transport == :none
+        if defined?(PusherFake)
+          path = ::Rails.application.routes.routes.detect do |route|
+            route.app == Hyperloop::Engine ||
+              (route.app.respond_to?(:app) && route.app.app == Hyperloop::Engine)
+          end.path.spec
+          pusher_fake_js = PusherFake.javascript(
+            auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
+            authEndpoint: "#{path}/hyperloop-pusher-auth"
+          )
+        end
+        controller.session.delete 'hyperloop-dummy-init' unless controller.session.id
+        id = "#{SecureRandom.uuid}-#{controller.session.id}"
+        auto_connections = Hyperloop::AutoConnect.channels(id, controller.acting_user)
       end
-      controller.session.delete 'hyperloop-dummy-init' unless controller.session.id
-      id = "#{SecureRandom.uuid}-#{controller.session.id}"
-      auto_connections = Hyperloop::AutoConnect.channels(id, controller.acting_user)
       config_hash = {
         transport: Hyperloop.transport,
         id: id,
         acting_user_id: (controller.acting_user && controller.acting_user.id),
+        env: ::Rails.env,
         client_logging: Hyperloop.client_logging,
         pusher_fake_js: pusher_fake_js,
         key: Hyperloop.key,
@@ -149,9 +171,27 @@ module Hyperloop
       attr_reader :opts
     end
 
+    isomorphic_method(:client_drivers_get_acting_user_id) do |f|
+      f.send_to_server if RUBY_ENGINE == 'opal'
+      f.when_on_server { (controller.acting_user && controller.acting_user.id) }
+    end
+
+    isomorphic_method(:env) do |f|
+      f.when_on_client { opts[:env] }
+      f.send_to_server
+      f.when_on_server { ::Rails.env }
+    end
+
+    def self.complete_connection(channel, retries = 10)
+      get_queued_data('connect-to-transport', channel).fail do
+        after(0.25) { complete_connection(channel, retries - 1) } unless retries.zero?
+      end
+    end
+
     def self.get_queued_data(operation, channel = nil, opts = {})
-      HTTP.get(polling_path(operation, channel), opts).then do |response|
+      Hyperloop::HTTP.get(polling_path(operation, channel), opts).then do |response|
         response.json.each do |data|
+          `console.log("simple_poller received: ", data)` if ClientDrivers.env == 'development'
           sync_dispatch(data[1])
         end
       end
@@ -161,21 +201,24 @@ module Hyperloop
 
       if @initialized
         # 1) skip initialization if already initialized
-        # 2) if running action_cable make sure connection is up after pinging the server_up
-        #    action cable closes the connection if files change on the server
-        HTTP.get("#{`window.HyperloopEnginePath`}/server_up") do
-          `#{Hyperloop.action_cable_consumer}.connection.open()` if `#{Hyperloop.action_cable_consumer}.connection.disconnected`
-        end if Hyperloop.action_cable_consumer
+        if on_opal_client? && Hyperloop.action_cable_consumer
+          # 2) if running action_cable make sure connection is up after pinging the server_up
+          #    action cable closes the connection if files change on the server
+          Hyperloop::HTTP.get("#{`window.HyperloopEnginePath`}/server_up") do
+            `#{Hyperloop.action_cable_consumer}.connection.open()` if `#{Hyperloop.action_cable_consumer}.connection.disconnected`
+          end
+        end
         return
       end
 
       @initialized = true
+      @opts = {}
+
+      if on_opal_client?
 
-      if RUBY_ENGINE == 'opal'
         @opts = Hash.new(`window.HyperloopOpts`)
-      end
 
-      if on_opal_client?
+
         if opts[:transport] == :pusher
 
           opts[:dispatch] = lambda do |data|
@@ -209,7 +252,7 @@ module Hyperloop
         elsif opts[:transport] == :simple_poller
           opts[:auto_connect].each { |channel| IncomingBroadcast.add_connection(*channel) }
           every(opts[:seconds_between_poll]) do
-            get_queued_data(:read, nil, headers: {'X-HYPERLOOP-SILENT-REQUEST' =>  true })
+            get_queued_data(:read, nil)
           end
         end
       end

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

@@ -1,20 +1,16 @@
 module Hyperloop
   module AutoCreate
-    def needs_init?
-      return false if Hyperloop.transport == :none
-      return true if connection.respond_to?(:data_sources) && !connection.data_sources.include?(table_name)
-      return true if !connection.respond_to?(:data_sources) && !connection.tables.include?(table_name)
-      return false unless Hyperloop.on_server?
-      return true if defined?(Rails::Server)
-      return true unless Connection.root_path
-      uri = URI("#{Connection.root_path}server_up")
-      http = Net::HTTP.new(uri.host, uri.port)
-      request = Net::HTTP::Get.new(uri.path)
-      if uri.scheme == 'https'
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    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
-      http.request(request) && return rescue true
+    end
+
+    def needs_init?
+      Hyperloop.transport != :none && Hyperloop.on_server? && !table_exists?
     end
 
     def create_table(*args, &block)
@@ -58,14 +54,14 @@ module Hyperloop
     extend AutoCreate
 
     def self.build_tables
-      create_table(force: true) do |t|
+      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: true) do |t|
+      QueuedMessage.create_table(force: :cascade) do |t|
         t.text    :data
         t.integer :connection_id
       end
@@ -106,6 +102,10 @@ module Hyperloop
       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 Hyperloop.on_server?
           expired.delete_all
           refresh_connections if needs_refresh?
@@ -153,9 +153,10 @@ module Hyperloop
       end
 
       def root_path
-        QueuedMessage.root_path
-      rescue
-        nil
+        # 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
@@ -163,7 +164,8 @@ module Hyperloop
         channels = transport.refresh_channels
         next_refresh = refresh_started_at + transport.refresh_channels_every
         channels.each do |channel|
-          find_by(channel: channel, session: nil).update(refresh_at: next_refresh)
+          connection = find_by(channel: channel, session: nil)
+          connection.update(refresh_at: next_refresh) if connection
         end
         inactive.delete_all
       end

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

@@ -122,7 +122,7 @@ module Hyperloop
   end
 
   def self.on_server?
-    Rails.const_defined? 'Server'
+    return defined? Rails::Server
   end
 
   def self.pusher

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

@@ -17,7 +17,7 @@ module Hyperloop
           unless method_defined? :pre_hyperloop_call
             alias pre_hyperloop_call call
             def call(env)
-              if !Hyperloop.opts[:noisy] && env['HTTP_X_HYPERLOOP_SILENT_REQUEST']
+              if Hyperloop.transport == :simple_poller && env['PATH_INFO'] && env['PATH_INFO'].include?('/hyperloop-read/')
                 Rails.logger.silence do
                   pre_hyperloop_call(env)
                 end
@@ -115,6 +115,7 @@ module Hyperloop
       end
 
       def pusher_auth
+        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
@@ -123,6 +124,7 @@ module Hyperloop
       end
 
       def action_cable_auth
+        raise unless Hyperloop.transport == :action_cable
         channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'')
         salt = SecureRandom.hex
         authorization = Hyperloop.authorization(salt, channel, client_id)
@@ -134,6 +136,8 @@ module Hyperloop
       def connect_to_transport
         root_path = request.original_url.gsub(/hyperloop-connect-to-transport.*$/, '')
         render json: Hyperloop::Connection.connect_to_transport(params[:channel], client_id, root_path)
+      rescue Exception => e
+        render status: :service_unavailable, json: {error: e}
       end
 
       def execute_remote
@@ -154,6 +158,7 @@ module Hyperloop
       end
 
       def console_update # TODO this should just become an execute-remote-api call
+        raise unless Rails.env.development?
         authorization = Hyperloop.authorization(params[:salt], params[:channel], params[:data][1][:broadcast_id]) #params[:data].to_json)
         return head :unauthorized if authorization != params[:authorization]
         Hyperloop::Connection.send_to_channel(params[:channel], params[:data])

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

@@ -3,6 +3,16 @@ 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
 
@@ -49,11 +59,17 @@ module Hyperloop
     end
 
     def dispatch_to(*args, &regulation)
-      actual_klass = regulated_klass.is_a?(Class) ? regulated_klass : regulated_klass.constantize rescue nil
-      actual_klass.dispatch_to(actual_klass) if actual_klass.respond_to? :dispatch_to
-      unless actual_klass.respond_to? :dispatch_to
-        raise 'you can only dispatch_to Operation classes'
-      end
+      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
 
@@ -82,14 +98,40 @@ module Hyperloop
       end
     end
 
+    def self.ar_base_descendants_map_cache
+      @ar_base_descendants_map_cache ||= ActiveRecord::Base.descendants.map(&:name)
+    end
+
     def get_ar_model(str)
-      str.is_a?(Class) ? str : Object.const_get(str)
-    rescue
-      raise "#{str} is not a class"
+      if str.is_a?(Class)
+        unless str <= ActiveRecord::Base
+          Hyperloop::InternalPolicy.raise_operation_access_violation(:non_ar_class, "#{str} is not a subclass of ActiveRecord::Base")
+        end
+        str
+      else
+        # we used to cache this here, but during eager loading the cache may get partially filled and never updated
+        # so this guard will fail, now performance will be suckish, as this guard, required for security, takes some ms
+        # def self.ar_base_descendants_map_cache
+        #   @ar_base_descendants_map_cache ||= ActiveRecord::Base.descendants.map(&:name)
+        # end
+        # 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.
+          Hyperloop::InternalPolicy.raise_operation_access_violation(:non_ar_class, "#{str} is either not defined or is not a subclass of ActiveRecord::Base")
+        end
+        Object.const_get(str)
+      end
+    end
+
+    def self.regulated_klasses
+      @regulated_klasses ||= Set.new
     end
 
     def regulate(regulation_klass, policy, args, &regulation)
       process_args(policy, regulation_klass.allowed_opts, args, regulation) do |regulated_klass, opts|
+        self.class.regulated_klasses << regulated_klass.to_s
         regulation_klass.add_regulation regulated_klass, opts, &regulation
       end
     end
@@ -201,8 +243,23 @@ module Hyperloop
   class ClassConnectionRegulation < Regulation
 
     def self.add_regulation(klass, opts={}, &regulation)
-      actual_klass = klass.is_a?(Class) ? klass : klass.constantize rescue nil
-      actual_klass.dispatch_to(actual_klass) if actual_klass.respond_to? :dispatch_to rescue nil
+      actual_klass = if klass.is_a?(Class)
+                       klass
+                     else
+                       begin
+                         klass.constantize
+                       rescue NameError
+                         nil
+                       end
+                     end
+      if actual_klass && actual_klass.respond_to?(:dispatch_to)
+        begin
+          actual_klass.dispatch_to(actual_klass)
+        rescue NoMethodError
+          # this is the case for ClassPolicy where the instance method :dispatch_to has been deleted.
+          nil
+        end
+      end
       super
     end
 
@@ -321,10 +378,18 @@ module Hyperloop
       @obj
     end
 
+    def self.raise_operation_access_violation(message, details)
+      Hyperloop.on_error(Hyperloop::AccessViolation, message, details)
+      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 Hyperloop::InternalClassPolicy.regulated_klasses.include?(channel[0])
+          Hyperloop::InternalPolicy.raise_operation_access_violation(:not_a_channel, "#{channel[0]} is not regulated channel class")
+        end
         object = Object.const_get(channel[0]).find(id)
         InstanceConnectionRegulation.connect(object, acting_user)
       else
@@ -486,7 +551,7 @@ module Hyperloop
 
   module PolicyAutoLoader
     def self.load(name, value)
-      const_get("#{name}Policy") if name && !(name =~ /Policy$/) && value.is_a?(Class)
+      const_get("#{name}Policy") if name && !name.end_with?("Policy".freeze) && value.is_a?(Class)
     rescue Exception => e
       raise e if e.is_a?(LoadError) && e.message =~ /Unable to autoload constant #{name}Policy/
     end
@@ -515,8 +580,8 @@ class Class
 
   Hyperloop::ClassPolicyMethods.instance_methods.each do |method|
     define_method method do |*args, &block|
-      if name =~ /Policy$/
-        @hyperloop_internal_policy_object = Hyperloop::InternalClassPolicy.new(name.gsub(/Policy$/,""))
+      if name.end_with?("Policy".freeze)
+        @hyperloop_internal_policy_object = Hyperloop::InternalClassPolicy.new(name.sub(/Policy$/,""))
         include Hyperloop::PolicyMethods
         send method, *args, &block
       else