hyper-operation 0.99.6 → 1.0.alpha1

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

@@ -3,7 +3,7 @@ module ApplicationCable
   class Connection < ActionCable::Connection::Base; end
 end
 
-module Hyperloop
+module Hyperstack
   class ActionCableChannel < ApplicationCable::Channel
     class << self
       def subscriptions
@@ -12,28 +12,28 @@ module Hyperloop
     end
 
     def inc_subscription
-      self.class.subscriptions[params[:hyperloop_channel]] =
-        self.class.subscriptions[params[:hyperloop_channel]] + 1
+      self.class.subscriptions[params[:hyperstack_channel]] =
+        self.class.subscriptions[params[:hyperstack_channel]] + 1
     end
 
     def dec_subscription
-      self.class.subscriptions[params[:hyperloop_channel]] =
-        self.class.subscriptions[params[:hyperloop_channel]] - 1
+      self.class.subscriptions[params[:hyperstack_channel]] =
+        self.class.subscriptions[params[:hyperstack_channel]] - 1
     end
 
     def subscribed
       session_id = params["client_id"]
-      authorization = Hyperloop.authorization(params["salt"], params["hyperloop_channel"], session_id)
+      authorization = Hyperstack.authorization(params["salt"], params["hyperstack_channel"], session_id)
       if params["authorization"] == authorization
         inc_subscription
-        stream_from "hyperloop-#{params[:hyperloop_channel]}"
+        stream_from "hyperstack-#{params[:hyperstack_channel]}"
       else
         reject
       end
     end
 
     def unsubscribed
-      Hyperloop::Connection.disconnect(params[:hyperloop_channel]) if dec_subscription == 0
+      Hyperstack::Connection.disconnect(params[:hyperstack_channel]) if dec_subscription == 0
     end
   end
 end

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

@@ -1,13 +1,13 @@
 #### this is going to need some refactoring so that HyperMesh can add its methods in here...
 
-module Hyperloop
+module Hyperstack
   # 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
-    extend React::IsomorphicHelpers::ClassMethods
+    extend Component::IsomorphicHelpers::ClassMethods
 
     if on_opal_client?
       def self.acting_user_id
@@ -46,7 +46,7 @@ module Hyperloop
     end
 
     def self.connect_session
-      connect(['Hyperloop::Session', ClientDrivers.opts[:id].split('-').last])
+      connect(['Hyperstack::Session', ClientDrivers.opts[:id].split('-').last])
     end
 
     def self.action_cable_consumer
@@ -76,14 +76,14 @@ module Hyperloop
           }
         elsif ClientDrivers.opts[:transport] == :action_cable
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
-          Hyperloop::HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel), headers: { 'X-CSRF-Token' => ClientDrivers.opts[:form_authenticity_token] }).then do |response|
+          Hyperstack::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(
+              #{Hyperstack.action_cable_consumer}.subscriptions.create(
                 {
-                  channel: "Hyperloop::ActionCableChannel",
+                  channel: "Hyperstack::ActionCableChannel",
                   client_id: #{ClientDrivers.opts[:id]},
-                  hyperloop_channel: #{channel_string},
+                  hyperstack_channel: #{channel_string},
                   authorization: #{response.json[:authorization]},
                   salt: #{response.json[:salt]}
                 },
@@ -101,14 +101,14 @@ module Hyperloop
             }
           end
         else
-          Hyperloop::HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
+          Hyperstack::HTTP.get(ClientDrivers.polling_path(:subscribe, channel_string))
         end
       end
     end
   end
 
   class ClientDrivers
-    include React::IsomorphicHelpers
+    include Hyperstack::Component::IsomorphicHelpers
 
     def self.sync_dispatch(data)
       # TODO old synchromesh double checked at this point to make sure that this client
@@ -116,7 +116,7 @@ module Hyperloop
       data[:operation].constantize.dispatch_from_server(data[:params])
     end
 
-    # save the configuration info needed in window.HyperloopOpts
+    # save the configuration info needed in window.HyperstackOpts
 
     # 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
@@ -125,45 +125,45 @@ module Hyperloop
     # will remove the session from the list.
 
     prerender_footer do |controller|
-      unless Hyperloop.transport == :none
+      unless Hyperstack.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)
+            route.app == Hyperstack::Engine ||
+              (route.app.respond_to?(:app) && route.app.app == Hyperstack::Engine)
           end.path.spec
           pusher_fake_js = PusherFake.javascript(
             auth: { headers: { 'X-CSRF-Token' => controller.send(:form_authenticity_token) } },
-            authEndpoint: "#{path}/hyperloop-pusher-auth"
+            authEndpoint: "#{path}/hyperstack-pusher-auth"
           )
         end
-        controller.session.delete 'hyperloop-dummy-init' unless controller.session.id
+        controller.session.delete 'hyperstack-dummy-init' unless controller.session.id
         id = "#{SecureRandom.uuid}-#{controller.session.id}"
-        auto_connections = Hyperloop::AutoConnect.channels(id, controller.acting_user)
+        auto_connections = Hyperstack::AutoConnect.channels(id, controller.acting_user) rescue []
       end
       config_hash = {
-        transport: Hyperloop.transport,
+        transport: Hyperstack.transport,
         id: id,
         acting_user_id: (controller.acting_user && controller.acting_user.id),
         env: ::Rails.env,
-        client_logging: Hyperloop.client_logging,
+        client_logging: Hyperstack.client_logging,
         pusher_fake_js: pusher_fake_js,
-        key: Hyperloop.key,
-        cluster: Hyperloop.cluster,
-        encrypted: Hyperloop.encrypted,
-        channel: Hyperloop.channel,
+        key: Hyperstack.key,
+        cluster: Hyperstack.cluster,
+        encrypted: Hyperstack.encrypted,
+        channel: Hyperstack.channel,
         form_authenticity_token: controller.send(:form_authenticity_token),
-        seconds_between_poll: Hyperloop.seconds_between_poll,
+        seconds_between_poll: Hyperstack.seconds_between_poll,
         auto_connect:  auto_connections
       }
       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)
+        route.app == Hyperstack::Engine or (route.app.respond_to?(:app) and route.app.app == Hyperstack::Engine)
       end
-      raise 'Hyperloop::Engine mount point not found.  Check your config/routes.rb file' unless path
+      raise 'Hyperstack::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"\
+        "window.HyperstackEnginePath = '#{path}';\n"\
+        "window.HyperstackOpts = #{config_hash.to_json}\n"\
       "</script>\n"
     end if RUBY_ENGINE != 'opal'
 
@@ -189,7 +189,7 @@ module Hyperloop
     end
 
     def self.get_queued_data(operation, channel = nil, opts = {})
-      Hyperloop::HTTP.get(polling_path(operation, channel), opts).then do |response|
+      Hyperstack::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])
@@ -201,11 +201,11 @@ module Hyperloop
 
       if @initialized
         # 1) skip initialization if already initialized
-        if on_opal_client? && Hyperloop.action_cable_consumer
+        if on_opal_client? && Hyperstack.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`
+          Hyperstack::HTTP.get("#{`window.HyperstackEnginePath`}/server_up") do
+            `#{Hyperstack.action_cable_consumer}.connection.open()` if `#{Hyperstack.action_cable_consumer}.connection.disconnected`
           end
         end
         return
@@ -216,7 +216,7 @@ module Hyperloop
 
       if on_opal_client?
 
-        @opts = Hash.new(`window.HyperloopOpts`)
+        @opts = Hash.new(`window.HyperstackOpts`)
 
 
         if opts[:transport] == :pusher
@@ -237,18 +237,18 @@ module Hyperloop
               h = {
                 encrypted: #{opts[:encrypted]},
                 cluster: #{opts[:cluster]},
-                authEndpoint: window.HyperloopEnginePath+'/hyperloop-pusher-auth',
+                authEndpoint: window.HyperstackEnginePath+'/hyperstack-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])
+          Hyperstack.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])
+          Hyperstack.connect(*opts[:auto_connect])
         elsif opts[:transport] == :simple_poller
           opts[:auto_connect].each { |channel| IncomingBroadcast.add_connection(*channel) }
           every(opts[:seconds_between_poll]) do
@@ -259,7 +259,7 @@ module Hyperloop
     end
 
     def self.polling_path(to, id = nil)
-      s = "#{`window.HyperloopEnginePath`}/hyperloop-#{to}/#{opts[:id]}"
+      s = "#{`window.HyperstackEnginePath`}/hyperstack-#{to}/#{opts[:id]}"
       s = "#{s}/#{id}" if id
       s
     end

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

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

data/lib/hyper-operation/transport/{hyperloop.rb → hyperstack.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 Hyperloop
+module Hyperstack
 
   def self.initialize_policies
     reset_operations unless @config_reset_called
@@ -13,9 +13,9 @@ module Hyperloop
   def self.reset_operations
     @config_reset_called = true
     Rails.configuration.tap do |config|
-      # 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.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 }
     end
     Object.send(:remove_const, :Application) if @fake_application_defined
@@ -37,10 +37,10 @@ module Hyperloop
       @fake_application_defined = true
     end
     begin
-      Object.const_get 'Hyperloop::ApplicationPolicy'
+      Object.const_get 'Hyperstack::ApplicationPolicy'
     rescue LoadError
     rescue NameError => e
-      raise e unless e.message =~ /uninitialized constant Hyperloop::ApplicationPolicy/
+      raise e unless e.message =~ /uninitialized constant Hyperstack::ApplicationPolicy/
     end
     @pusher = nil
   end
@@ -49,10 +49,10 @@ module Hyperloop
     if transport == :action_cable
       require 'hyper-operation/transport/action_cable'
       opts[:refresh_channels_every] = :never
-      import 'action_cable', client_only: true if Rails.configuration.hyperloop.auto_config
+      import 'action_cable', client_only: true if Rails.configuration.hyperstack.auto_config
     elsif transport == :pusher
       require 'pusher'
-      import 'hyperloop/pusher', client_only: true if Rails.configuration.hyperloop.auto_config
+      import 'hyperstack/pusher', client_only: true if Rails.configuration.hyperstack.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
@@ -107,7 +107,7 @@ module Hyperloop
 
   def self.refresh_channels
     new_channels = pusher.channels[:channels].collect do |channel, _etc|
-      channel.gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/, '').gsub('==', '::')
+      channel.gsub(/^#{Regexp.quote(Hyperstack.channel)}\-/, '').gsub('==', '::')
     end
   end
 
@@ -115,9 +115,9 @@ module Hyperloop
     if !on_server?
       send_to_server(channel, data)
     elsif transport == :pusher
-      pusher.trigger("#{Hyperloop.channel}-#{data[1][:channel].gsub('::', '==')}", *data)
+      pusher.trigger("#{Hyperstack.channel}-#{data[1][:channel].gsub('::', '==')}", *data)
     elsif transport == :action_cable
-      ActionCable.server.broadcast("hyperloop-#{channel}", message: data[0], data: data[1])
+      ActionCable.server.broadcast("hyperstack-#{channel}", message: data[0], data: data[1])
     end
   end
 
@@ -167,8 +167,8 @@ module Hyperloop
   end
 
   def self.dispatch(data)
-    if !Hyperloop.on_server? && Connection.root_path
-      Hyperloop.send_to_server(data[:channel], [:dispatch, data])
+    if !Hyperstack.on_server? && Connection.root_path
+      Hyperstack.send_to_server(data[:channel], [:dispatch, data])
     else
       Connection.send_to_channel(data[:channel], [:dispatch, data])
     end

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

@@ -1,6 +1,6 @@
-module Hyperloop
-  ::Hyperloop::Engine.routes.append do
-    Hyperloop.initialize_policies
+module Hyperstack
+  ::Hyperstack::Engine.routes.append do
+    Hyperstack.initialize_policies
 
     module ::WebConsole
       class Middleware
@@ -14,15 +14,15 @@ module Hyperloop
     module ::Rails
       module Rack
         class Logger < ActiveSupport::LogSubscriber
-          unless method_defined? :pre_hyperloop_call
-            alias pre_hyperloop_call call
+          unless method_defined? :pre_hyperstack_call
+            alias pre_hyperstack_call call
             def call(env)
-              if Hyperloop.transport == :simple_poller && env['PATH_INFO'] && env['PATH_INFO'].include?('/hyperloop-read/')
+              if Hyperstack.transport == :simple_poller && env['PATH_INFO'] && env['PATH_INFO'].include?('/hyperstack-read/')
                 Rails.logger.silence do
-                  pre_hyperloop_call(env)
+                  pre_hyperstack_call(env)
                 end
               else
-                pre_hyperloop_call(env)
+                pre_hyperstack_call(env)
               end
             end
           end
@@ -30,7 +30,7 @@ module Hyperloop
       end
     end if defined?(::Rails::Rack::Logger)
 
-    class HyperloopController < ::ApplicationController
+    class HyperstackController < ::ApplicationController
 
       protect_from_forgery except: [:console_update, :execute_remote_api]
 
@@ -39,28 +39,28 @@ module Hyperloop
       end
 
       before_action do
-        session.delete 'hyperloop-dummy-init' unless session.id
+        session.delete 'hyperstack-dummy-init' unless session.id
       end
 
       def session_channel
-        "Hyperloop::Session-#{session.id}"
+        "Hyperstack::Session-#{session.id}"
       end
 
       def regulate(channel)
-        unless channel == session_channel # "Hyperloop::Session-#{client_id.split('-').last}"
-          Hyperloop::InternalPolicy.regulate_connection(try(:acting_user), channel)
+        unless channel == session_channel # "Hyperstack::Session-#{client_id.split('-').last}"
+          Hyperstack::InternalPolicy.regulate_connection(try(:acting_user), channel)
         end
         channel
       end
 
       def channels(user = acting_user, session_id = session.id)
-        Hyperloop::AutoConnect.channels(session_id, user)
+        Hyperstack::AutoConnect.channels(session_id, user)
       end
 
       def can_connect?(channel, user = acting_user)
-        Hyperloop::InternalPolicy.regulate_connection(
+        Hyperstack::InternalPolicy.regulate_connection(
           user,
-          Hyperloop::InternalPolicy.channel_to_string(channel)
+          Hyperstack::InternalPolicy.channel_to_string(channel)
         )
         true
       rescue
@@ -101,41 +101,41 @@ module Hyperloop
 
       def subscribe
         channel = regulate params[:channel].gsub('==', '::')
-        root_path = request.original_url.gsub(/hyperloop-subscribe.*$/, '')
-        Hyperloop::Connection.open(channel, client_id, root_path)
+        root_path = request.original_url.gsub(/hyperstack-subscribe.*$/, '')
+        Hyperstack::Connection.open(channel, client_id, root_path)
         head :ok
       rescue Exception
         head :unauthorized
       end
 
       def read
-        root_path = request.original_url.gsub(/hyperloop-read.*$/, '')
-        data = Hyperloop::Connection.read(client_id, root_path)
+        root_path = request.original_url.gsub(/hyperstack-read.*$/, '')
+        data = Hyperstack::Connection.read(client_id, root_path)
         render json: data
       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])
+        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])
         render json: response
       rescue Exception => e
         head :unauthorized
       end
 
       def action_cable_auth
-        raise unless Hyperloop.transport == :action_cable
-        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'')
+        raise unless Hyperstack.transport == :action_cable
+        channel = regulate params[:channel_name].gsub(/^#{Regexp.quote(Hyperstack.channel)}\-/,'')
         salt = SecureRandom.hex
-        authorization = Hyperloop.authorization(salt, channel, client_id)
+        authorization = Hyperstack.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(/hyperloop-connect-to-transport.*$/, '')
-        render json: Hyperloop::Connection.connect_to_transport(params[:channel], client_id, root_path)
+        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}
       end
@@ -159,9 +159,9 @@ module Hyperloop
 
       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)
+        authorization = Hyperstack.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])
+        Hyperstack::Connection.send_to_channel(params[:channel], params[:data])
         head :no_content
       rescue
         head :unauthorized
@@ -171,32 +171,32 @@ module Hyperloop
         head :no_content
       end
 
-    end unless defined? Hyperloop::HyperloopController
+    end unless defined? Hyperstack::HyperstackController
 
     match 'execute_remote',
-          to: 'hyperloop#execute_remote', via: :post
+          to: 'hyperstack#execute_remote', via: :post
     match 'execute_remote_api',
-          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
+          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
     match 'console',
-          to: 'hyperloop#debug_console', via: :get
+          to: 'hyperstack#debug_console', via: :get
     match 'console_update',
-          to: 'hyperloop#console_update', via: :post
+          to: 'hyperstack#console_update', via: :post
     match 'server_up',
-          to: 'hyperloop#server_up', via: :get
+          to: 'hyperstack#server_up', via: :get
   end
 end