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

data/lib/hyper-operation/async_sleep.rb

@@ -1,23 +0,0 @@
-module Hyperstack
-  module AsyncSleep
-    if RUBY_ENGINE == 'opal'
-      def self.every(*args, &block)
-        every(*args, &block)
-      end
-
-      def self.after(*args, &block)
-        after(*args, &block)
-      end
-    else
-      extend self
-
-      def every(time, &block)
-        Thread.new { loop { sleep time; block.call } }
-      end
-
-      def after(time, &block)
-        Thread.new { sleep time; block.call }
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'active_record/connection'
-require_relative 'active_record/queued_message'
-
-module Hyperstack
-  module ConnectionAdapter
-    module ActiveRecord
-      class << self
-        def build_tables
-          Connection.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: :cascade) do |t|
-            t.text    :data
-            t.integer :connection_id
-          end
-        end
-
-        def transport
-          Hyperstack::Connection.transport
-        end
-
-        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 Connection.table_exists?
-
-          if Hyperstack.on_server?
-            Connection.expired.delete_all
-            refresh_connections if Connection.needs_refresh?
-          end
-
-          Connection.all.pluck(:channel).uniq
-        rescue ::ActiveRecord::StatementInvalid
-          []
-        end
-
-        def open(channel, session = nil, root_path = nil)
-          self.root_path = root_path
-
-          Connection.find_or_create_by(channel: channel, session: session)
-        end
-
-        def send_to_channel(channel, data)
-          Connection.pending_for(channel).each do |connection|
-            QueuedMessage.create(data: data, hyperstack_connection: connection)
-          end
-
-          transport.send_data(channel, data) if Connection.exists?(channel: channel, session: nil)
-        end
-
-        def read(session, root_path)
-          self.root_path = root_path
-
-          Connection.where(session: session)
-                    .update_all(expires_at: Time.current + 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 = Connection.find_by(channel: channel, session: session))
-            messages = connection.messages.pluck(:data)
-            connection.destroy
-          else
-            messages = []
-          end
-
-          open(channel)
-
-          messages
-        end
-
-        def disconnect(channel)
-          Connection.find_by(channel: channel, session: nil).destroy
-        end
-
-        def root_path=(path)
-          QueuedMessage.root_path = path if path
-        end
-
-        def root_path
-          # 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
-          refresh_started_at = Time.current
-          channels = transport.refresh_channels
-          next_refresh = refresh_started_at + transport.refresh_channels_every
-
-          channels.each do |channel|
-            connection = Connection.find_by(channel: channel, session: nil)
-            connection.update(refresh_at: next_refresh) if connection
-          end
-
-          Connection.inactive.delete_all
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Hyperstack
-  module ConnectionAdapter
-    module ActiveRecord
-      module AutoCreate
-        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
-        end
-
-        def needs_init?
-          Hyperstack.transport != :none && Hyperstack.on_server? && !table_exists?
-        end
-
-        def create_table(*args, &block)
-          connection.create_table(table_name, *args, &block) if needs_init?
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'auto_create'
-
-module Hyperstack
-  module ConnectionAdapter
-    module ActiveRecord
-      class Connection < ::ActiveRecord::Base
-        extend AutoCreate
-
-        self.table_name = 'hyperstack_connections'
-
-        do_not_synchronize
-
-        has_many :messages,
-                foreign_key: 'connection_id',
-                class_name: 'Hyperstack::ConnectionAdapter::ActiveRecord::QueuedMessage',
-                dependent: :destroy
-
-        scope :expired,
-              -> { where('expires_at IS NOT NULL AND expires_at < ?', Time.current) }
-        scope :pending_for,
-              ->(channel) { where(channel: channel).where('session IS NOT NULL') }
-        scope :inactive,
-              -> { where('session IS NULL AND refresh_at < ?', Time.current) }
-
-        before_create do
-          if session
-            self.expires_at = Time.current + transport.expire_new_connection_in
-          elsif transport.refresh_channels_every != :never
-            self.refresh_at = Time.current + transport.refresh_channels_every
-          end
-        end
-
-        class << self
-          def needs_refresh?
-            exists?(['refresh_at IS NOT NULL AND refresh_at < ?', Time.current])
-          end
-        end
-
-        def transport
-          Hyperstack::Connection.transport
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'auto_create'
-
-module Hyperstack
-  module ConnectionAdapter
-    module ActiveRecord
-      class QueuedMessage < ::ActiveRecord::Base
-        extend AutoCreate
-
-        self.table_name = 'hyperstack_queued_messages'
-
-        do_not_synchronize
-
-        serialize :data
-
-        belongs_to :hyperstack_connection,
-                   class_name:  'Hyperstack::ConnectionAdapter::ActiveRecord::Connection',
-                   foreign_key: 'connection_id',
-                   optional:    true
-
-        scope :for_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
-        # communicate back to the server. The belongs_to connection
-        # therefore must be optional.
-
-        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
-    end
-  end
-end

data/lib/hyper-operation/transport/connection_adapter/redis.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'redis/connection'
-require_relative 'redis/queued_message'
-
-module Hyperstack
-  module ConnectionAdapter
-    module Redis
-      class << self
-        def transport
-          Hyperstack::Connection.transport
-        end
-
-        def active
-          if Hyperstack.on_server?
-            Connection.expired.each(&:destroy)
-            refresh_connections if Connection.needs_refresh?
-          end
-
-          Connection.all.map(&:channel).uniq
-        end
-
-        def open(channel, session = nil, root_path = nil)
-          self.root_path = root_path
-
-          Connection.find_or_create_by(channel: channel, session: session)
-        end
-
-        def send_to_channel(channel, data)
-          Connection.pending_for(channel).each do |connection|
-            QueuedMessage.create(connection_id: connection.id, data: data)
-          end
-
-          transport.send_data(channel, data) if Connection.exists?(channel: channel, session: nil)
-        end
-
-        def read(session, root_path)
-          self.root_path = root_path
-
-          Connection.where(session: session).each do |connection|
-            connection.update(expires_at: Time.current + transport.expire_polled_connection_in)
-          end
-
-          messages = QueuedMessage.for_session(session)
-          data = messages.map(&:data)
-          messages.each(&:destroy)
-          data
-        end
-
-        def connect_to_transport(channel, session, root_path)
-          self.root_path = root_path
-
-          if (connection = Connection.find_by(channel: channel, session: session))
-            messages = connection.messages.map(&:data)
-            connection.destroy
-          else
-            messages = []
-          end
-
-          open(channel)
-
-          messages
-        end
-
-        def disconnect(channel)
-          Connection.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.current
-          channels = transport.refresh_channels
-          next_refresh = refresh_started_at + transport.refresh_channels_every
-
-          channels.each do |channel|
-            connection = Connection.find_by(channel: channel, session: nil)
-            connection.update(refresh_at: next_refresh) if connection
-          end
-
-          Connection.inactive.each(&:destroy)
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'redis_record'
-
-module Hyperstack
-  module ConnectionAdapter
-    module Redis
-      class Connection < RedisRecord::Base
-        self.table_name = 'hyperstack:connections'
-        self.column_names = %w[id channel session created_at expires_at refresh_at].freeze
-
-        attr_accessor(*column_names.map(&:to_sym))
-
-        class << self
-          def transport
-            Hyperstack::Connection.transport
-          end
-
-          def create(opts = {})
-            opts.tap do |hash|
-              if opts[:session]
-                hash[:expires_at] = (Time.current + transport.expire_new_connection_in)
-              elsif transport.refresh_channels_every != :never
-                hash[:refresh_at] = (Time.current + transport.refresh_channels_every)
-              end
-
-              hash[:created_at] = Time.current
-            end.to_a.flatten
-
-            super(opts)
-          end
-
-          def inactive
-            scope { |id| id if inactive?(id) }
-          end
-
-          def inactive?(id)
-            get_dejsonized_attribute(id, :session).blank? &&
-              get_dejsonized_attribute(id, :refresh_at).present? &&
-              Time.zone.parse(get_dejsonized_attribute(id, :refresh_at)) < Time.current
-          end
-
-          def expired
-            scope { |id| id if expired?(id) }
-          end
-
-          def expired?(id)
-            get_dejsonized_attribute(id, :expires_at).present? &&
-              Time.zone.parse(get_dejsonized_attribute(id, :expires_at)) < Time.current
-          end
-
-          def pending_for(channel)
-            scope { |id| id if pending_for?(id, channel) }
-          end
-
-          def pending_for?(id, channel)
-            get_dejsonized_attribute(id, :session).present? &&
-              get_dejsonized_attribute(id, :channel) == channel
-          end
-
-          def needs_refresh?
-            scope { |id| id if needs_refresh(id) }.any?
-          end
-
-          def needs_refresh(id)
-            get_dejsonized_attribute(id, :refresh_at).present? &&
-              Time.zone.parse(get_dejsonized_attribute(id, :refresh_at)) < Time.current
-          end
-        end
-
-        def messages
-          QueuedMessage.where(connection_id: id)
-        end
-
-        %i[created_at expires_at refresh_at].each do |attr|
-          define_method(attr) do
-            value = instance_variable_get(:"@#{attr}")
-
-            value.is_a?(Time) ? value : Time.zone.parse(value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hyper-operation/transport/connection_adapter/redis/queued_message.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'redis_record'
-
-module Hyperstack
-  module ConnectionAdapter
-    module Redis
-      class QueuedMessage < RedisRecord::Base
-        self.table_name = 'hyperstack:queued_messages'
-        self.column_names = %w[id data connection_id].freeze
-
-        attr_accessor(*column_names.map(&:to_sym))
-
-        class << self
-          def for_session(session)
-            Connection.where(session: session).map(&:messages).flatten
-          end
-
-          def root_path=(path)
-            find_or_create_by(connection_id: 0).update(data: path)
-          end
-
-          def root_path
-            find_or_create_by(connection_id: 0).data
-          end
-        end
-
-        def connection
-          Connection.find(connection_id)
-        end
-      end
-    end
-  end
-end