hyper-operation 0.5.0

data/lib/hyper-operation/server_op.rb

@@ -0,0 +1,98 @@
+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]
+        end
+      end if RUBY_ENGINE == 'opal'
+
+      def run_from_client(security_param, operation, params)
+        operation.constantize.class_eval do
+          raise AccessViolation unless _Railway.params_wrapper.method_defined? security_param
+          run(params)
+          .then { |r| return { json: { response: serialize_response(r) } } }
+          .fail { |e| return { json: { error: e}, status: 500 } }
+        end
+      rescue Exception => e
+        { json: {error: e}, status: 500 }
+      end
+
+      def remote(path, *args)
+        promise = Promise.new
+        uri = URI("#{path}execute_remote_api")
+        http = Net::HTTP.new(uri.host, uri.port)
+        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,
+          params: Hyperloop::Operation::ParamsWrapper.combine_arg_array(args)
+        }.to_json
+        promise.resolve http.request(request)
+      rescue Exception => e
+        promise.reject e
+      end
+
+      def serialize_params(hash)
+        hash
+      end
+
+      def deserialize_params(hash)
+        hash
+      end
+
+      def serialize_response(hash)
+        hash
+      end
+
+      def deserialize_response(hash)
+        hash
+      end
+
+      def serialize_dispatch(hash)
+        hash
+      end
+
+      def deserialize_dispatch(hash)
+        hash
+      end
+
+      def dispatch_to(*args, &regulation)
+        _dispatch_to(nil, args, &regulation) if RUBY_ENGINE != 'opal'
+      end
+
+      def _dispatch_to(context, args=[], &regulation)
+        if args.count == 0 && regulation.nil?
+          raise "must provide either a list of channel classes or a block to regulate_dispatch"
+        elsif args.count > 0 && regulation
+          raise "cannot provide both a list of channel classes and a block to regulate_dispatch"
+        end
+        regulation ||= proc { args }
+        on_dispatch do |params, operation|
+          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)
+          end
+        end
+      end if RUBY_ENGINE != 'opal'
+
+      def dispatch_from_server(params_hash)
+        params = _Railway.params_wrapper.new(deserialize_dispatch(params_hash)).lock
+        _Railway.receivers.each { |receiver| receiver.call params }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+class ActionController::Base
+
+  def acting_user
+  end
+
+end

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

@@ -0,0 +1,39 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base; end
+  class Connection < ActionCable::Connection::Base; end
+end
+
+module Hyperloop
+  class ActionCableChannel < ApplicationCable::Channel
+    class << self
+      def subscriptions
+        @subscriptions ||= Hash.new { |h, k| h[k] = 0 }
+      end
+    end
+
+    def inc_subscription
+      self.class.subscriptions[params[:hyperloop_channel]] =
+        self.class.subscriptions[params[:hyperloop_channel]] + 1
+    end
+
+    def dec_subscription
+      self.class.subscriptions[params[:hyperloop_channel]] =
+        self.class.subscriptions[params[:hyperloop_channel]] - 1
+    end
+
+    def subscribed
+      session_id = params["client_id"]
+      authorization = Hyperloop.authorization(params["salt"], params["hyperloop_channel"], session_id)
+      if params["authorization"] == authorization
+        inc_subscription
+        stream_from "hyperloop-#{params[:hyperloop_channel]}"
+      else
+        reject
+      end
+    end
+
+    def unsubscribed
+      Hyperloop::Connection.disconnect(params[:hyperloop_channel]) if dec_subscription == 0
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Base
+
+    class << self
+
+      def do_not_synchronize
+        @do_not_synchronize = true
+      end
+
+      def do_not_synchronize?
+        @do_not_synchronize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+#### this is going to need some refactoring so that HyperMesh can add its methods in here...
+
+module Hyperloop
+  # Client side handling of synchronization messages
+  # When a synchronization message comes in, the client will sync_dispatch
+  # We use ERB to determine the configuration and implement the appropriate
+  # client interface to sync_change or sync_destroy
+
+  class Application
+    def self.acting_user_id
+      ClientDrivers.opts[:acting_user_id]
+    end
+  end
+
+
+  if RUBY_ENGINE == 'opal'
+    def self.connect(*channels)
+      channels.each do |channel|
+        if channel.is_a? Class
+          IncomingBroadcast.connect_to(channel.name)
+        elsif channel.is_a?(String) || channel.is_a?(Array)
+          IncomingBroadcast.connect_to(*channel)
+        elsif channel.id
+          IncomingBroadcast.connect_to(channel.class.name, channel.id)
+        else
+          raise "cannot connect to model before it has been saved"
+        end
+      end
+    end
+
+    def self.action_cable_consumer
+      ClientDrivers.opts[:action_cable_consumer]
+    end
+
+    class IncomingBroadcast
+
+      def self.open_channels
+        @open_channels ||= Set.new
+      end
+
+      def self.add_connection(channel_name, id = nil)
+        channel_string = "#{channel_name}#{'-'+id.to_s if id}"
+        open_channels << channel_string
+        channel_string
+      end
+
+      def self.connect_to(channel_name, id = nil)
+        channel_string = add_connection(channel_name, id)
+        if ClientDrivers.opts[:transport] == :pusher
+          channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
+          %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)}})
+          }
+        elsif ClientDrivers.opts[:transport] == :action_cable
+          channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
+          HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel)).then do |response|
+            %x{
+              #{Hyperloop.action_cable_consumer}.subscriptions.create(
+                {
+                  channel: "Hyperloop::ActionCableChannel",
+                  client_id: #{ClientDrivers.opts[:id]},
+                  hyperloop_channel: #{channel_string},
+                  authorization: #{response.json[:authorization]},
+                  salt: #{response.json[:salt]}
+                },
+                {
+                  connected: function() {
+                    #{ClientDrivers.get_queued_data("connect-to-transport", channel_string)}
+                  },
+                  received: function(data) {
+                    #{ClientDrivers.sync_dispatch(JSON.parse(`JSON.stringify(data)`)['data'])}
+                  }
+                }
+              )
+            }
+          end
+        else
+          HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
+        end
+      end
+    end
+  end
+
+  class ClientDrivers
+    include React::IsomorphicHelpers
+
+    def self.sync_dispatch(data)
+      # TODO old synchromesh double checked at this point to make sure that this client
+      # expected to recieve from the channel the data was sent on.  Was that really needed?
+      data[:operation].constantize.dispatch_from_server(data[:params])
+    end
+
+    # save the configuration info needed in window.HyperloopOpts
+
+    # we keep a list of all channels by session with connections in progress
+    # for each broadcast we check the list, and add the message to a queue for that
+    # session.  When the client is informed that the connection has completed
+    # we call the server,  this will return ALL the broadcasts (cool) and
+    # will remove the session from the list.
+
+    prerender_footer do |controller|
+      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}"
+      config_hash = {
+        transport: Hyperloop.transport,
+        id: id,
+        acting_user_id: (controller.acting_user && controller.acting_user.id),
+        client_logging: Hyperloop.client_logging,
+        pusher_fake_js: pusher_fake_js,
+        key: Hyperloop.key,
+        encrypted: Hyperloop.encrypted,
+        channel: Hyperloop.channel,
+        form_authenticity_token: controller.send(:form_authenticity_token),
+        seconds_between_poll: Hyperloop.seconds_between_poll,
+        auto_connect: Hyperloop::AutoConnect.channels(id, controller.acting_user)
+      }
+      path = ::Rails.application.routes.routes.detect do |route|
+        # not sure why the second check is needed.  It happens in the test app
+        route.app == Hyperloop::Engine or (route.app.respond_to?(:app) and route.app.app == Hyperloop::Engine)
+      end
+      raise 'Hyperloop::Engine mount point not found.  Check your config/routes.rb file' unless path
+      path = path.path.spec
+      "<script type='text/javascript'>\n"\
+        "window.HyperloopEnginePath = '#{path}';\n"\
+        "window.HyperloopOpts = #{config_hash.to_json}\n"\
+      "</script>\n"
+    end if RUBY_ENGINE != 'opal'
+
+    class << self
+      attr_reader :opts
+    end
+
+    def self.get_queued_data(operation, channel = nil, opts = {})
+      HTTP.get(polling_path(operation, channel), opts).then do |response|
+        response.json.each do |data|
+          #send "sync_#{update[0]}", update[1]
+          sync_dispatch(data[1])
+        end
+      end
+    end
+
+    # called from ReactiveRecord::Base before_first_mount hook
+    # to insure this is done first.
+
+    ####### TODO TODO TODO make sure to provide a hook that calls reactive record base AFTER this.. (hey use the boot hook)
+    def self.initialize_client_drivers_on_boot
+
+      if RUBY_ENGINE == 'opal'
+        @opts = Hash.new(`window.HyperloopOpts`)
+      end
+
+      if on_opal_client?
+
+        if opts[:transport] == :pusher
+
+          opts[:dispatch] = lambda do |data|
+            sync_dispatch JSON.parse(`JSON.stringify(#{data})`)
+          end
+
+          if opts[:client_logging] && `window.console && window.console.log`
+            `Pusher.log = function(message) {window.console.log(message);}`
+          end
+          if opts[:pusher_fake_js]
+            opts[:pusher_api] = `eval(#{opts[:pusher_fake_js]})`
+          else
+            h = nil
+            pusher_api = nil
+            %x{
+              h = {
+                encrypted: #{opts[:encrypted]},
+                authEndpoint: window.HyperloopEnginePath+'/hyperloop-pusher-auth',
+                auth: {headers: {'X-CSRF-Token': #{opts[:form_authenticity_token]}}}
+              };
+              pusher_api = new Pusher(#{opts[:key]}, h)
+            }
+            opts[:pusher_api] = pusher_api
+          end
+          Hyperloop.connect(*opts[:auto_connect])
+        elsif opts[:transport] == :action_cable
+          opts[:action_cable_consumer] =
+            `ActionCable.createConsumer.apply(ActionCable, #{[*opts[:action_cable_consumer_url]]})`
+          Hyperloop.connect(*opts[:auto_connect])
+        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 })
+          end
+        end
+      end
+    end
+
+    def self.polling_path(to, id = nil)
+      s = "#{`window.HyperloopEnginePath`}/hyperloop-#{to}/#{opts[:id]}"
+      s = "#{s}/#{id}" if id
+      s
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+module Hyperloop
+  module AutoCreate
+    def needs_init?
+      return true unless 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
+      end
+      http.request(request) && return rescue true
+    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
+
+      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 self.root_path
+        unscoped.find_or_create_by(connection_id: 0).data
+      end
+    end
+
+    extend AutoCreate
+
+    def self.build_tables
+      create_table(force: true) 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|
+        t.text    :data
+        t.integer :connection_id
+      end
+    end
+
+    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
+
+    class << self
+      attr_accessor :transport
+
+      def active
+        if Hyperloop.on_server?
+          expired.delete_all
+          refresh_connections if needs_refresh?
+        end
+        all.pluck(:channel).uniq
+      end
+
+      def open(channel, session = nil, root_path = nil)
+        self.root_path = root_path
+        find_or_create_by(channel: channel, session: session)
+      end
+
+      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)
+        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)
+        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)
+        find_by(channel: channel, session: nil).destroy
+      end
+
+      def root_path=(path)
+        QueuedMessage.root_path = path if path
+      end
+
+      def root_path
+        QueuedMessage.root_path
+      rescue
+        nil
+      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|
+          find_by(channel: channel, session: nil).update(refresh_at: next_refresh)
+        end
+        inactive.delete_all
+      end
+    end
+  end
+end