hyper-operation 0.5.0

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

@@ -0,0 +1,165 @@
+# Provides the configuration and the two basic routines for the server
+# to indicate that records have changed: after_change and after_destroy
+module Hyperloop
+
+  def self.initialize_policies
+    reset_operations unless @config_reset_called
+  end
+
+  on_config_reset do
+    reset_operations
+  end
+
+  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.after_initialize { Connection.build_tables }
+    end
+    Object.send(:remove_const, :Application) if @fake_application_defined
+    policy = begin
+      Object.const_get 'ApplicationPolicy'
+    rescue Exception => e
+      #raise e unless e.is_a?(NameError) && e.message == "uninitialized constant ApplicationPolicy"
+    rescue LoadError
+    end
+    application = begin
+      Object.const_get('Application')
+    rescue LoadError
+    rescue Exception => e
+      #raise e unless e.is_a?(NameError) && e.message == "uninitialized constant Application"
+    end if policy
+    if policy && !application
+      Object.const_set 'Application', Class.new
+      @fake_application_defined = true
+    end
+    @pusher = nil
+  end
+
+  define_setting(:transport, :none) do |transport|
+    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
+    elsif transport == :pusher
+      require 'pusher'
+      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 :opts, {}
+  define_setting :channel_prefix, 'synchromesh'
+  define_setting :client_logging, true
+
+  def self.app_id
+    opts[:app_id] || Pusher.app_id if transport == :pusher
+  end
+
+  def self.key
+    opts[:key] || Pusher.key if transport == :pusher
+  end
+
+  def self.secret
+    opts[:secret] || Pusher.secret if transport == :pusher
+  end
+
+  def self.encrypted
+    opts.key?(:encrypted) ? opts[:encrypted] : true
+  end
+
+  def self.expire_polled_connection_in
+    opts[:expire_polled_connection_in] || (5 * 60)
+  end
+
+  def self.seconds_between_poll
+    opts[:seconds_between_poll] || 0.5
+  end
+
+  def self.expire_new_connection_in
+    opts[:expire_new_connection_in] || 10.seconds
+  end
+
+  def self.refresh_channels_timeout
+    opts[:refresh_channels_timeout] || 5.seconds
+  end
+
+  def self.refresh_channels_every
+    opts[:refresh_channels_every] || 2.minutes
+  end
+
+  def self.refresh_channels
+    new_channels = pusher.channels[:channels].collect do |channel, _etc|
+      channel.gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/, '').gsub('==', '::')
+    end
+  end
+
+  def self.send_data(channel, data)
+    if !on_server?
+      send_to_server(channel, data)
+    elsif transport == :pusher
+      pusher.trigger("#{Hyperloop.channel}-#{data[1][:channel].gsub('::', '==')}", *data)
+    elsif transport == :action_cable
+      ActionCable.server.broadcast("hyperloop-#{channel}", message: data[0], data: data[1])
+    end
+  end
+
+  def self.on_server?
+    Rails.const_defined? 'Server'
+  end
+
+  def self.pusher
+    unless @pusher
+      unless channel_prefix
+        self.transport = nil
+        raise '******** NO CHANNEL PREFIX SET ***************'
+      end
+      @pusher = Pusher::Client.new(
+        opts || { app_id: app_id, key: key, secret: secret }
+      )
+    end
+    @pusher
+  end
+
+  def self.channel
+    "private-#{channel_prefix}"
+  end
+
+  def self.authorization(salt, channel, session_id)
+    secret_key = Rails.application.secrets[:secret_key_base]
+    Digest::SHA1.hexdigest(
+      "salt: #{salt}, channel: #{channel}, session_id: #{session_id}, secret_key: #{secret_key}"
+    )
+  end
+
+  def self.send_to_server(channel, data) # TODO this should work the same/similar to HyperMesh / Models way of sending to console
+    salt = SecureRandom.hex
+    authorization = authorization(salt, channel, data[1][:broadcast_id])
+    raise 'no server running' unless Connection.root_path
+    uri = URI("#{Connection.root_path}console_update")
+    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 = {
+      channel: channel, data: data, salt: salt, authorization: authorization
+    }.to_json
+    http.request(request)
+  end
+
+  def self.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
+  end
+
+  Connection.transport = self
+end

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

@@ -0,0 +1,184 @@
+module Hyperloop
+  ::Hyperloop::Engine.routes.append do
+    Hyperloop.initialize_policies
+
+    module ::WebConsole
+      class Middleware
+      private
+        def acceptable_content_type?(headers)
+          Mime::Type.parse(headers['Content-Type'] || '').first == Mime[:html]
+        end
+      end
+    end if defined? ::WebConsole::Middleware
+
+    module ::Rails
+      module Rack
+        class Logger < ActiveSupport::LogSubscriber
+          unless method_defined? :pre_hyperloop_call
+            alias pre_hyperloop_call call
+            def call(env)
+              if !Hyperloop.opts[:noisy] && env['HTTP_X_HYPERLOOP_SILENT_REQUEST']
+                Rails.logger.silence do
+                  pre_hyperloop_call(env)
+                end
+              else
+                pre_hyperloop_call(env)
+              end
+            end
+          end
+        end
+      end
+    end if defined?(::Rails::Rack::Logger)
+
+    class HyperloopController < ::ApplicationController
+
+      protect_from_forgery except: [:console_update, :execute_remote_api]
+
+      def client_id
+        params[:client_id]
+      end
+
+      before_action do
+        session.delete 'hyperloop-dummy-init' unless session.id
+      end
+
+      def channels(user = acting_user, session_id = session.id)
+        Hyperloop::AutoConnect.channels(session_id, user)
+      end
+
+      def can_connect?(channel, user = acting_user)
+        Hyperloop::InternalPolicy.regulate_connection(
+          user,
+          Hyperloop::InternalPolicy.channel_to_string(channel)
+        )
+        true
+      rescue
+        nil
+      end
+
+      def view_permitted?(model, attr, user = acting_user)
+        !!model.check_permission_with_acting_user(user, :view_permitted?, attr)
+      rescue
+        nil
+      end
+
+      def viewable_attributes(model, user = acting_user)
+        model.attributes.select { |attr| view_permitted?(model, attr, user) }
+      end
+
+      [:create, :update, :destroy].each do |op|
+        define_method "#{op}_permitted?" do |model, user = acting_user|
+          begin
+            !!model.check_permission_with_acting_user(user, "#{op}_permitted?".to_sym)
+          rescue
+            nil
+          end
+        end
+      end
+
+      def debug_console
+        if Rails.env.development?
+          render inline: "<style>div#console {height: 100% !important;}</style>\n".html_safe
+          #  "<div>additional helper methods: channels, can_connect? "\
+          #  "viewable_attributes, view_permitted?, create_permitted?, "\
+          #  "update_permitted? and destroy_permitted?</div>\n".html_safe
+          console
+        else
+          head :unauthorized
+        end
+      end
+
+      def subscribe
+        channel = params[:channel].gsub('==', '::')
+        Hyperloop::InternalPolicy.regulate_connection(try(:acting_user), channel)
+        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(/hyperloop-read.*$/, '')
+        data = Hyperloop::Connection.read(client_id, root_path)
+        render json: data
+      end
+
+      def pusher_auth
+        channel = params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'').gsub('==', '::')
+        Hyperloop::InternalPolicy.regulate_connection(acting_user, channel)
+        response = Hyperloop.pusher.authenticate(params[:channel_name], params[:socket_id])
+        render json: response
+      rescue Exception => e
+        head :unauthorized
+      end
+
+      def action_cable_auth
+        channel = params[:channel_name].gsub(/^#{Regexp.quote(Hyperloop.channel)}\-/,'')
+        Hyperloop::InternalPolicy.regulate_connection(acting_user, channel)
+        salt = SecureRandom.hex
+        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(/hyperloop-connect-to-transport.*$/, '')
+        render json: Hyperloop::Connection.connect_to_transport(params[:channel], client_id, root_path)
+      end
+
+      def execute_remote
+        parsed_params = JSON.parse(params[:json]).symbolize_keys
+        render ServerOp.run_from_client(
+          :acting_user, parsed_params[:operation], parsed_params[:params].merge(acting_user: acting_user))
+      end
+
+      def execute_remote_api
+        parsed_params = params[:params].symbolize_keys
+        raise AccessViolation unless parsed_params[:authorization]
+        render ServerOp.run_from_client(:authorization, params[:operation], parsed_params)
+      end
+
+      def console_update # TODO this should just become an execute-remote-api call
+        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])
+        head :no_content
+      rescue
+        head :unauthorized
+      end
+
+      def server_up
+        head :no_content
+      end
+
+    end unless defined? HyperloopController
+
+    match 'execute_remote',
+          to: 'hyperloop#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
+    match 'console',
+          to: 'hyperloop#debug_console', via: :get
+    match 'console_update',
+          to: 'hyperloop#console_update', via: :post
+    match 'server_up',
+          to: 'hyperloop#server_up', via: :get
+  end
+end

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

@@ -0,0 +1,6 @@
+# Add pluck to enumerable... its already done for us in rails 5+
+module Enumerable
+  def pluck(key)
+    map { |element| element[key] }
+  end
+end unless Enumerable.method_defined? :pluck

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

@@ -0,0 +1,535 @@
+module Hyperloop
+
+  class InternalClassPolicy
+
+    def initialize(regulated_klass)
+      @regulated_klass = regulated_klass
+    end
+
+    attr_reader :regulated_klass
+
+    EXPOSED_METHODS = [
+      :regulate_class_connection, :always_allow_connection, :regulate_instance_connections,
+      :regulate_all_broadcasts, :regulate_broadcast,
+      :dispatch_to, :regulate_dispatches_from, :always_dispatch_from,
+      :allow_change, :allow_create, :allow_read, :allow_update, :allow_destroy
+    ]
+
+    def regulate_class_connection(*args, &regulation)
+      regulate(ClassConnectionRegulation, :class_connection, args, &regulation)
+    end
+
+    def always_allow_connection(*args)
+      regulate(ClassConnectionRegulation, nil, args) { true }
+    end
+
+    def regulate_instance_connections(*args, &regulation)
+      regulate(InstanceConnectionRegulation, :instance_connections, args, &regulation)
+    end
+
+    def regulate_all_broadcasts(*args, &regulation)
+      regulate(ChannelBroadcastRegulation, :all_broadcasts, args, &regulation)
+    end
+
+    def regulate_broadcast(*args, &regulation)
+      regulate(InstanceBroadcastRegulation, :broadcast, args, &regulation)
+    end
+
+    def regulate_dispatches_from(*args, &regulation)
+      args.each do |klass|
+        unless klass.respond_to? :dispatch_to
+          raise 'you can only regulate_dispatches_from Operation classes'
+        end
+        klass._dispatch_to(self) { |sself| sself.regulated_klass if instance_eval(&regulation) }
+      end
+    end
+
+    def always_dispatch_from(*args, &regulation)
+      regulate_dispatches_from(*args) { true }
+    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.dispatch_to(*args, &regulation)
+    end
+
+    CHANGE_POLICIES = [:create, :update, :destroy]
+
+    def self.allow_policy(policy, method)
+      define_method "allow_#{policy}" do |*args, &regulation|
+        process_args(policy, [], args, regulation) do |model|
+          get_ar_model(model).class_eval { define_method("#{method}_permitted?", &regulation) }
+        end
+      end
+    end
+
+    CHANGE_POLICIES.each { |policy| allow_policy policy, policy }
+
+    allow_policy(:read, :view)
+
+    def allow_change(*args, &regulation)
+      process_args('change', [:on], args, regulation) do |model, opts|
+        model = get_ar_model(model)
+        opts[:on] ||= CHANGE_POLICIES
+        opts[:on].each do |policy|
+          check_valid_on_option policy
+          model.class_eval { define_method("#{policy}_permitted?", &regulation) }
+        end
+      end
+    end
+
+    def get_ar_model(str)
+      str.is_a?(Class) ? str : Object.const_get(str)
+    rescue
+      raise "#{str} is not a class"
+    end
+
+    def regulate(regulation_klass, policy, args, &regulation)
+      process_args(policy, regulation_klass.allowed_opts, args, regulation) do |regulated_klass, opts|
+        regulation_klass.add_regulation regulated_klass, opts, &regulation
+      end
+    end
+
+    def process_args(policy, allowed_opts, args, regulation)
+      raise "you must provide a block to the regulate_#{policy} method" unless regulation
+      *args, opts = args if args.last.is_a? Hash
+      opts ||= {}
+      args = process_to_opt(allowed_opts, opts, args)
+      args.each do |regulated_klass|
+        yield regulated_klass, opts
+      end
+    end
+
+    def process_to_opt(allowed_opts, opts, args)
+      opts.each do |opt, value|
+        unless opt == :to || allowed_opts.include?(opt)
+          raise "Unknown ':#{opt} => #{value}' option in policy definition"
+        end
+      end
+      if (to = opts[:to])
+        raise "option to: :#{to} is not recognized in allow_#{policy}" unless to == :all
+        raise "option to: :all cannot be used with other classes" unless args.empty?
+        [ActiveRecord::Base]
+      elsif args.empty?
+        [@regulated_klass]
+      else
+        args
+      end
+    end
+
+    def check_valid_on_option(policy)
+      unless CHANGE_POLICIES.include? policy
+        valid_policies = CHANGE_POLICIES.collect { |s| ":{s}" }.to_sentence
+        raise "only #{valid_policies} are allowed on the regulate_access :on option"
+      end
+    end
+
+  end
+
+  class Regulation
+
+    class << self
+
+      def add_regulation(klass, opts={}, &regulation)
+        klass = regulations[klass]
+        klass.opts.merge! opts
+        klass.regulations << regulation
+        klass
+      end
+
+      def regulations
+        @regulations ||= Hash.new do |hash, klass|
+          if klass.is_a? String
+            hash[klass] = new(klass)
+          elsif klass.is_a?(Class) && klass.name
+            hash[klass.name]
+          else
+            hash[klass.class.name]
+          end
+        end
+      end
+
+      def wrap_policy(policy, regulation)
+        begin
+          policy_klass = regulation.binding.receiver
+        rescue
+          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.hyperloop_internal_policy_object = policy
+        wrapped_policy
+      end
+
+      def allowed_opts
+        []
+      end
+
+    end
+
+    attr_reader :klass
+
+    def opts
+      @opts ||= {}
+    end
+
+    def regulations
+      @regulations ||= []
+    end
+
+    def regulate_for(acting_user)
+      Enumerator.new do |y|
+        regulations.each do |regulation|
+          y << acting_user.instance_eval(&regulation)
+        end
+      end
+    end
+
+    def auto_connect_disabled?
+      opts.has_key?(:auto_connect) && !opts[:auto_connect]
+    end
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+  end
+
+  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
+      super
+    end
+
+    def connectable?(acting_user)
+      regulate_for(acting_user).all? unless regulations.empty? rescue nil
+    end
+
+    def self.connect(channel, acting_user)
+      raise "connection failed" unless regulations[channel].connectable?(acting_user)
+    end
+
+    def self.connections_for(acting_user, auto_connections_only)
+      regulations.collect do |channel, regulation|
+        next if auto_connections_only && regulation.auto_connect_disabled?
+        next if !regulation.connectable?(acting_user)
+        channel
+      end.compact
+    end
+
+    def self.allowed_opts
+      [:auto_connect]
+    end
+
+  end
+
+  class InstanceConnectionRegulation < Regulation
+
+    def connectable_to(acting_user, auto_connections_only)
+      return [] if auto_connections_only && auto_connect_disabled?
+      regulate_for(acting_user).entries.compact.flatten(1) rescue []
+    end
+
+    def self.connect(instance, acting_user)
+      unless regulations[instance].connectable_to(acting_user, false).include? instance
+        raise "connection failed"
+      end
+    end
+
+    def self.connections_for(acting_user, auto_connections_only)
+      regulations.collect do |_channel, regulation|
+        # the following was bizarelly passing true for auto_connections_only????
+        regulation.connectable_to(acting_user, auto_connections_only).collect do |obj|
+          if false && auto_connections_only # false added to try to get channel instances to connect???
+            [obj.class.name, obj.id]
+          else
+           InternalPolicy.channel_to_string obj
+         end
+        end
+      end.flatten(1)
+    end
+
+    def self.allowed_opts
+      [:auto_connect]
+    end
+  end
+
+  class ChannelBroadcastRegulation < Regulation
+    class << self
+      def add_regulation(channel, opts={}, &regulation)
+        regulations_to_channels[regulation] << super
+      end
+
+      def broadcast(policy)
+        regulations_to_channels.each do |regulation, channels|
+          wrapped_policy = wrap_policy(policy, regulation)
+          channels.each do |channel|
+            regulation.call wrapped_policy
+            policy.send_unassigned_sets_to channel.klass
+          end
+        end
+      end
+
+      def regulations_to_channels
+        @regulations_to_channels ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+  end
+
+  class InstanceBroadcastRegulation < Regulation
+    def self.broadcast(instance, policy)
+      regulations[instance].regulations.each do |regulation|
+        instance.instance_exec wrap_policy(policy, regulation), &regulation
+      end
+      if policy.has_unassigned_sets?
+        raise "#{instance.class.name} instance broadcast policy not sent to any channel"
+      end
+    end
+  end
+
+  module AutoConnect
+    def self.channels(session, acting_user)
+      channels = ClassConnectionRegulation.connections_for(acting_user, true) +
+        InstanceConnectionRegulation.connections_for(acting_user, true)
+      channels = channels.uniq
+      channels.each do |channel|
+        Connection.open(channel, session)
+      end
+      channels
+    end
+  end
+
+  class InternalPolicy
+
+    EXPOSED_METHODS = [:send_all, :send_all_but, :send_only, :obj]
+
+    def send_all
+      SendSet.new(self)
+    end
+
+    def send_all_but(*execeptions)
+      SendSet.new(self, exclude: execeptions)
+    end
+
+    def send_only(*white_list)
+      SendSet.new(self, white_list: white_list)
+    end
+
+    def obj
+      @obj
+    end
+
+    def self.regulate_connection(acting_user, channel_string)
+      channel = channel_string.split("-")
+      if channel.length > 1
+        id = channel[1..-1].join("-")
+        object = Object.const_get(channel[0]).find(id)
+        InstanceConnectionRegulation.connect(object, acting_user)
+      else
+        ClassConnectionRegulation.connect(channel[0], acting_user)
+      end
+    end
+
+    def self.regulate_broadcast(model, &block)
+      internal_policy = InternalPolicy.new(
+        model, model.attribute_names, Connection.active
+      )
+      ChannelBroadcastRegulation.broadcast(internal_policy)
+      InstanceBroadcastRegulation.broadcast(model, internal_policy)
+      internal_policy.broadcast &block
+    end
+
+    def initialize(obj, attribute_names, available_channels)
+      @obj = obj
+      attribute_names = attribute_names.map(&:to_sym).to_set
+      @unassigned_send_sets = []
+      @channel_sets = Hash.new { |hash, key| hash[key] = attribute_names }
+      @available_channels = available_channels
+    end
+
+    def channel_available?(channel)
+      channel && @available_channels.include?(channel_to_string(channel))
+    end
+
+    def id
+      @id ||= "#{self.object_id}-#{Time.now.to_f}"
+    end
+
+    def has_unassigned_sets?
+      !@unassigned_send_sets.empty?
+    end
+
+    def send_unassigned_sets_to(channel)
+      if channel_available?(channel) && has_unassigned_sets?
+        @channel_sets[channel] = @unassigned_send_sets.inject(@channel_sets[channel]) do |set, send_set|
+          send_set.merge(set)
+        end
+      end
+      @unassigned_send_sets = []
+    end
+
+    def add_unassigned_send_set(send_set)
+      @unassigned_send_sets << send_set
+    end
+
+    def send_set_to(send_set, channels)
+      channels.flatten(1).each do |channel|
+        merge_set(send_set, channel) if channel_available? channel
+        @unassigned_send_sets.delete(send_set)
+      end
+    end
+
+    def merge_set(send_set, channel)
+      return unless channel
+      channel = channel.name if channel.is_a?(Class) && channel.name
+      @channel_sets[channel] = send_set.merge(@channel_sets[channel])
+    end
+
+    def channel_list
+      @channel_sets.collect { |channel, _value| channel_to_string channel }
+    end
+
+    def self.channel_to_string(channel)
+      if channel.is_a?(Class) && channel.name
+        channel.name
+      elsif channel.is_a? String
+        channel
+      else
+        "#{channel.class.name}-#{channel.id}"
+      end
+    end
+
+    def channel_to_string(channel)
+      self.class.channel_to_string(channel)
+    end
+
+    def filter(h, attribute_set)
+      r = {}
+      h.each do |key, value|
+        r[key.to_sym] = value if attribute_set.member?(key.to_sym) || (key.to_sym == :id)
+      end unless attribute_set.empty?
+      #model_id = h[:id] || h["id"]
+      #r[:id] = model_id if model_id && !attribute_set.empty?
+      r
+    end
+
+    def send_message(header, channel, attribute_set, &block)
+      record = filter(@obj.react_serializer, attribute_set)
+      previous_changes = filter(@obj.previous_changes, attribute_set)
+      return if record.empty? && previous_changes.empty?
+      message = header.merge(
+        channel: channel_to_string(channel),
+        record: record,
+        previous_changes: previous_changes
+      )
+      yield message
+    end
+
+    def broadcast(&block)
+      klass = @obj.class
+      header = {broadcast_id: id, channels: channel_list, klass: klass.name}
+      @channel_sets.each do |channel, attribute_set|
+        send_message header, channel, attribute_set, &block
+      end
+    end
+  end
+
+  class SendSet
+
+    def to(*channels)
+      @policy.send_set_to(self, channels)
+    end
+
+    def initialize(policy, exclude: nil, white_list: nil)
+      @policy = policy
+      @policy.add_unassigned_send_set(self)
+      @excluded = exclude.map &:to_sym if exclude
+      @white_list = white_list.map &:to_sym if white_list
+    end
+
+    def merge(set)
+      set = set.difference(@excluded) if @excluded
+      set = set.intersection(@white_list) if @white_list
+      set
+    end
+
+  end
+
+  module ClassPolicyMethods
+    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|
+        hyperloop_internal_policy_object.send policy_method, *klasses, &block
+      end unless respond_to? policy_method
+    end
+  end
+
+  module PolicyMethods
+    def self.included(base)
+      base.class_eval do
+        extend ClassPolicyMethods
+      end
+    end
+    attr_accessor :hyperloop_internal_policy_object
+    InternalPolicy::EXPOSED_METHODS.each do |method|
+      define_method method do |*args, &block|
+        hyperloop_internal_policy_object.send method, *args, &block
+      end unless respond_to? method
+    end
+    define_method :initialize do |*args|
+    end unless instance_methods(false).include?(:initialize)
+  end
+
+  module PolicyAutoLoader
+    def self.load(name, value)
+      const_get("#{name}Policy") if name && !(name =~ /Policy$/) && value.is_a?(Class)
+    rescue Exception => e
+      raise e if e.is_a?(LoadError) && e.message =~ /Unable to autoload constant #{name}Policy/
+    end
+  end
+end
+
+class Module
+  alias pre_hyperloop_const_set const_set
+
+  def const_set(name, value)
+    pre_hyperloop_const_set(name, value).tap do
+      Hyperloop::PolicyAutoLoader.load(name, value)
+    end
+  end
+end
+
+class Class
+
+  alias pre_hyperloop_inherited inherited
+
+  def inherited(child_class)
+    pre_hyperloop_inherited(child_class).tap do
+      Hyperloop::PolicyAutoLoader.load(child_class.name, child_class)
+    end
+  end
+
+  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$/,""))
+        include Hyperloop::PolicyMethods
+        send method, *args, &block
+      else
+        class << self
+          Hyperloop::ClassPolicyMethods.instance_methods.each do |method|
+            undef_method method
+          end
+        end
+        method_missing(method, *args, &block)
+      end
+    end unless respond_to? method
+  end
+end