hyper-operation 1.0.alpha1.5 → 1.0.alpha1.6

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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,94 @@
+# 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

@@ -0,0 +1,85 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Hyperstack
+  module ConnectionAdapter
+    module Redis
+      module RedisRecord
+        class Base
+          class << self
+            attr_accessor :table_name, :column_names
+
+            def client
+              @client ||= ::Redis.new(url: Hyperstack.connection[:redis_url])
+            end
+
+            def scope(&block)
+              ids = client.smembers(table_name)
+
+              ids = ids.map(&block) if block
+
+              ids.compact.map { |id| instantiate(id) }
+            end
+
+            def all
+              scope
+            end
+
+            def first
+              id = client.smembers(table_name).first
+
+              instantiate(id)
+            end
+
+            def last
+              id = client.smembers(table_name).last
+
+              instantiate(id)
+            end
+
+            def find(id)
+              return unless client.smembers(table_name).include?(id)
+
+              instantiate(id)
+            end
+
+            def find_by(opts)
+              found = nil
+
+              client.smembers(table_name).each do |id|
+                unless opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
+                  found = instantiate(id)
+                  break
+                end
+              end
+
+              found
+            end
+
+            def find_or_create_by(opts = {})
+              if (existing = find_by(opts))
+                existing
+              else
+                create(opts)
+              end
+            end
+
+            def where(opts = {})
+              scope do |id|
+                unless opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
+                  id
+                end
+              end
+            end
+
+            def exists?(opts = {})
+              !!client.smembers(table_name).detect do |id|
+                !opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
+              end
+            end
+
+            def create(opts = {})
+              record = new({ id: SecureRandom.uuid }.merge(opts))
+
+              record.save
+
+              record
+            end
+
+            def destroy_all
+              all.each(&:destroy)
+
+              true
+            end
+
+            def jsonize_attributes(attrs)
+              attrs.map do |attr, value|
+                [attr, value.to_json]
+              end.to_h
+            end
+
+            def dejsonize_attributes(attrs)
+              attrs.map do |attr, value|
+                [attr, value && JSON.parse(value)]
+              end.to_h
+            end
+
+            protected
+
+            def instantiate(id)
+              new(dejsonize_attributes(client.hgetall("#{table_name}:#{id}")))
+            end
+
+            def get_dejsonized_attribute(id, attr)
+              value = client.hget("#{table_name}:#{id}", attr)
+              JSON.parse(value) if value
+            end
+          end
+
+          def initialize(opts = {})
+            opts.each { |k, v| send(:"#{k}=", v) }
+          end
+
+          def save
+            self.class.client.hmset("#{table_name}:#{id}", *self.class.jsonize_attributes(attributes))
+
+            unless self.class.client.smembers(table_name).include?(id)
+              self.class.client.sadd(table_name, id)
+            end
+
+            true
+          end
+
+          def update(opts = {})
+            opts.each { |k, v| send(:"#{k}=", v) }
+            save
+          end
+
+          def destroy
+            self.class.client.srem(table_name, id)
+
+            self.class.client.hdel("#{table_name}:#{id}", attributes.keys)
+
+            true
+          end
+
+          def attributes
+            self.class.column_names.map do |column_name|
+              [column_name, instance_variable_get("@#{column_name}")]
+            end.to_h
+          end
+
+          def table_name
+            self.class.table_name
+          end
+        end
+      end
+    end
+  end
+end