pollen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e74b102b1d0c5428838a6c35792a1da697a36c9679a642ab349a1d66f11b05e
+  data.tar.gz: a9fb42c9e8b9f1bb3ef2534b44b5947cb1c6ce1138ebbee7aafddc99ac1e280c
+SHA512:
+  metadata.gz: 785f8d2ff608600db96f9d7b8e297568c626804a85a1e2f1ea2fb2f01dfd49e55c9923f3bbb7d92a7b889d54cc7052d37bb05a08f00fed55e5c09f8e8ba0e282
+  data.tar.gz: e247e3d5e15fa504db27316eb77ba1ebc82939b8ca197fd6b67dc2cd05bb09b2ef196df5085da6d8d5980e73314efa215d312e77506e04f90fe29991ea2e9d1c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Jef Mathiot
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,205 @@
+# Pollen
+
+An HTTP pubsub engine allowing clients to wait for long running tasks and get data updates
+from the server.
+
+## How it works
+
+Pollen allows client applications to subscribe to streams of server-sent events.
+
+![Getting started](https://github.com/EverestHC-mySofie/pollen/blob/main/resources/pollen-getting-started.png?raw=true)
+
+When a client application wants to subscribe to a steam, it opens an HTTP connection with the
+Pollen server. Pollen hijacks Rack requests corresponding to a specific route set (`/pollens/streams/:stream_id`)
+and opens long running HTTP connections handled by an event loop and Ruby Fibers. All requests
+outside this route are ignored by Pollen and forwarded to Rails.
+
+On the server-side, processes, such as background jobs, use the Pollen controller to push updates
+and handle the streams states. Communication between the controllers and the server is performed
+via Redis Pub/Sub.
+
+Thanks to the event loop and the usage of Ruby Fibers, Pollen can handle 10k+ concurrent connections
+on a single CPU.
+
+![Event Loop](https://github.com/EverestHC-mySofie/pollen/blob/main/resources/pollen-event-loop.png?raw=true)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "pollen"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install pollen
+```
+
+To install the migrations into your Rails application:
+
+```bash
+rails pollen:install:migrations
+```
+
+## Usage
+
+### Authenticate stream clients
+
+We create a module that extracts access tokens from requests:
+
+```ruby
+# lib/token_extractor.rb
+
+module TokenExtractor
+  class << self
+    def token(request)
+      pattern = /^Bearer /
+      header  = request.get_header('HTTP_AUTHORIZATION')
+      return unless header&.match(pattern)
+
+      header.gsub(pattern, '')
+    end
+  end
+end
+```
+
+### Start the pollen server
+
+We then create an initializer to provide the Redis client and the authentication method to the
+Pollen server.  We also start the Pollen server if the environment variable `START_POLLEN` is
+set to `true`.
+
+```ruby
+# config/initializers/pollen.rb
+
+# Configuration shared by servers and controllers
+Pollen.common.configure do |c|
+  c.redis Redis.new(url: "redis://127.0.0.1:6379")
+end
+
+Pollen.server.configure do |c|
+  c.authenticate do |request, env|
+    token = TokenExtractor.token(request)
+    next if token.blank?
+
+    AccessToken.find_by(token: token)&.user
+  end
+end
+
+Pollen.server.start! if ENV['START_POLLEN'] == 'true'
+```
+
+### Push events using the controller
+
+Now, when the client application calls Rails to perform long-running task, such as generating 
+the quaterly report of the _World Company®_, a regular Rails controller authenticates the
+user, creates a _Stream_ instance and enqueues a background job. It then renders the _Stream_.
+
+```ruby
+# app/controllers/admin/reports_controller.rb
+
+module Admin
+  class ReportsController < ActionController::API
+    before_action :authenticate_user
+
+    def create
+      stream = Pollen::Stream.create!(owner: current_user, timeout: 600)
+      GenerateQuarterlyReportJob.perform_later(stream)
+      render json: stream
+    end
+  end
+end
+```
+
+When the client application gets the response, it uses the _Stream_ identifier to open a
+connection to the Pollen server. It provides its access token so that the Pollen server
+can authenticate the connection. As soon as the client has connected to the _Stream_, it
+will get the initial status of the _Stream_ and regular heartbeats (every 10 seconds, by
+default):
+
+```bash
+$ curl -N -H "Authorization: Bearer d87bdfe991fd4b892fc49e145c7dc8e38477b2ec08eee2aeb07441658a7a8c57" \
+  http://0.0.0.0:3000/pollen/streams/708100af-2eba-4db3-b0a2-1847abee202c
+event: pending
+event: heartbeat
+event: heartbeat
+```
+
+The job performs the report generation and regularly notifies the client application using
+the Pollen controller. Once the report is fully generated, the controller marks the stream
+as completed and closes the connection:
+
+```ruby
+# app/jobs/generate_quaterly_report_job.rb
+
+class GenerateQuarterlyReportJob < ApplicationJob
+  def perform(stream)
+    10.times do |i|
+      Pollen.controller.push!(stream, :update, { step: i }.to_json)
+      sleep 1
+    end
+    Report.create!
+    Pollen.controller.completed!(stream, report.to_json)
+  rescue
+    Pollen.controller.failed!(stream, {})
+  end
+end
+```
+
+The client will see this stream of events before the server closes the connection:
+
+```
+event: heartbeat
+event: update
+data: {"step":0}
+event: update
+data: {"step":1}
+event: heartbeat
+event: update
+data: {"step":2}
+event: update
+data: {"step":3}
+event: update
+data: {"step":4}
+event: update
+data: {"step":5}
+event: update
+data: {"step":6}
+event: update
+data: {"step":7}
+event: heartbeat
+event: update
+data: {"step":8}
+event: update
+data: {"step":9}
+event: completed
+data: {"id":"702943d6-49e4-45ba-9a6f-630fadd3e2c7"}
+event: terminated
+```
+
+### Delete old streams
+
+Stream instances are stored in the database and, in high traffic environments,
+may pile up to millions of records a day.
+
+Pollen provides a `pollen:prune_streams` Rails task typically run from a scheduled
+task such as a Cron job. As _Stream_ objects are basically _ActiveRecord_ models,
+it is also possible to use plain-old ActiveRecord queries to delete oldest _Streams_.
+
+### Configuration
+
+See the [wiki](https://github.com/EverestHC-mySofie/pollen/wiki/Configuration) for configuration options.
+
+## Contributing
+
+Feel free to file an issue or create a pull request <3
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/models/pollen/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pollen
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/pollen/stream.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Stream < ApplicationRecord
+    belongs_to :owner, class_name: Pollen.common.configuration.owner_class
+
+    enum :status, pending: 0, completed: 10, failed: 20
+
+    validates :timeout, numericality: { only_integer: true, greater_than: 0 }
+
+    before_validation(on: :create) do
+      self.id = SecureRandom.uuid unless id.present?
+    end
+  end
+end

data/db/migrate/20241125150719_create_pollen_streams.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreatePollenStreams < ActiveRecord::Migration[7.2]
+  def change
+    create_table :pollen_streams, id: false, primary_key: :id do |t|
+      t.string :id, primary_key: true
+      t.string :owner_id, index: true
+      t.text :payload
+      t.integer :status, null: false, default: 0
+      t.integer :timeout, null: false, default: 120
+      t.timestamps
+    end
+  end
+end

data/lib/pollen/commands.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pollen
+  module Commands
+    def completed!(stream_or_id, payload)
+      push!(stream_or_id, :completed, payload)
+    end
+
+    def failed!(stream_or_id, payload)
+      push!(stream_or_id, :failed, payload)
+    end
+
+    def push!(stream_or_id, event, payload)
+      check_redis!
+      stream = load_stream(stream_or_id)
+      stream.update!(status: %i[completed failed].include?(event) && event || :pending, payload:)
+      with_redis do |r|
+        r.publish("#{configuration.channel_prefix}:#{stream.id}", "#{event}:#{payload}")
+      end
+    end
+
+    private
+
+    def redis
+      configuration.redis
+    end
+
+    def with_redis(&block)
+      # Allow raw Redis clients or a client from the pool
+      configuration.redis.then(&block)
+    end
+
+    def check_redis!
+      return unless redis.nil?
+
+      raise Errors::InvalidConfiguration,
+            'Redis not set, please assign a Redis client or connection pool in controller configuration'
+    end
+
+    def load_stream(stream_or_id)
+      (stream_or_id.respond_to?(:id) && stream_or_id || Stream.find(stream_or_id)).tap do |stream|
+        unless stream.pending?
+          raise Errors::InvalidStreamStatus,
+                "Stream with id #{stream.id} is already #{stream.status}"
+        end
+      end
+    end
+  end
+end

data/lib/pollen/configuration.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Configuration
+    attr_reader :owner_class, :channel_prefix, :redis
+
+    def initialize
+      super
+      @owner_class = nil
+      @channel_prefix = nil
+      @redis = nil
+    end
+
+    def assign_defaults
+      @owner_class = 'User'
+      @channel_prefix = 'pollen:streams'
+    end
+
+    def root
+      self
+    end
+  end
+
+  class ServerConfiguration < Configuration
+    UUID_REGEXP = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+
+    attr_reader :concurrency, :heartbeat, :route_regexp
+    attr_accessor :authenticator
+
+    def initialize
+      super
+      @concurrency = 1
+      @heartbeat = 5
+      @route_regexp = %r{^/pollen/streams/(#{UUID_REGEXP})}
+      @authenticator = ->(_, _) {}
+    end
+  end
+
+  class ControllerConfiguration < Configuration
+    attr_reader :retention
+
+    def initialize
+      super
+      @retention = 24.hours
+    end
+  end
+
+  class CompositeConfiguration
+    def initialize(*configs)
+      @configs = configs
+    end
+
+    def method_missing(name, *_args, **_)
+      @configs.each do |config|
+        return config.send(name) if config.respond_to?(name) && !config.send(name).nil?
+      end
+      nil
+    end
+
+    def respond_to_missing?(name, _ = false)
+      @configs.map { |config| config.respond_to?(name) }.any?
+    end
+
+    def root
+      @configs.first
+    end
+  end
+
+  class ConfigurationBuilder
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def authenticate(&block)
+      @configuration.root.authenticator = block
+    end
+
+    def method_missing(name, *args, **_)
+      @configuration.root.instance_variable_set("@#{name}", *args)
+    end
+
+    def respond_to_missing?(_name, _ = false)
+      true
+    end
+  end
+
+  module Configurable
+    def configure
+      yield ConfigurationBuilder.new(configuration)
+    end
+  end
+
+  class Common
+    include Configurable
+
+    def configuration
+      @configuration ||= Configuration.new.tap(&:assign_defaults)
+    end
+  end
+end

data/lib/pollen/controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Controller
+    include Configurable
+    include Commands
+
+    def configuration
+      return @configuration if @configuration
+
+      @configuration = CompositeConfiguration.new(
+        ControllerConfiguration.new,
+        Pollen.common.configuration
+      )
+    end
+  end
+end

data/lib/pollen/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pollen
+  if defined?(::Rails)
+    class Engine < ::Rails::Engine
+      isolate_namespace Pollen
+
+      initializer 'pollen.add_middleware' do |app|
+        app.middleware.insert_after ActionDispatch::Executor, Pollen::Middleware
+      end
+
+      config.generators do |g|
+        g.test_framework :rspec
+        g.fixture_replacement :factory_bot
+        g.factory_bot dir: 'spec/factories'
+      end
+    end
+  end
+end

data/lib/pollen/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pollen
+  module Errors
+    class InvalidConfiguration < StandardError; end
+    class InvalidStreamStatus < StandardError; end
+    class AuthenticationFailure < StandardError; end
+    class StreamNotFound < StandardError; end
+  end
+end

data/lib/pollen/event_loop.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pollen
+  class EventLoop
+    def initialize
+      @fibers = {}
+    end
+
+    def proceed(incoming, queue)
+      incoming.each { |connection| start_fiber!(connection) }
+      collector = {}
+      @fibers.each do |stream_id, stream_fibers|
+        resume_stream_fibers(stream_id, stream_fibers, queue[stream_id], collector)
+      end
+      prune collector
+    end
+
+    private
+
+    def resume_stream_fibers(stream_id, fibers, event, collector)
+      fibers.each do |fiber|
+        fiber.resume event
+      rescue FiberError
+        # The fiber is dead
+        collector[stream_id] ||= []
+        collector[stream_id] << fiber
+        Rails.logger.info "Closed connection for stream #{stream_id}"
+      end
+    end
+
+    def prune(collector)
+      collector.each do |stream_id, stream_fibers|
+        stream_fibers.each do |fiber|
+          @fibers[stream_id].delete(fiber)
+        end
+        @fibers.delete(stream_id) if @fibers[stream_id].empty?
+      end
+    end
+
+    def start_fiber!(connection)
+      fiber = Fiber.new { |conn| FiberBody.new.execute!(conn) }
+      @fibers[connection.stream_id] ||= []
+      @fibers[connection.stream_id] << fiber.tap { |f| f.resume(connection) }
+    end
+  end
+end

data/lib/pollen/fiber_body.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pollen
+  class FiberBody
+    def initialize
+      @latest_heartbeat = Time.now.to_i
+    end
+
+    # TODO: Assign a Fiber scheduler to handle blocking kernel calls
+    def execute!(connection)
+      init!(connection)
+      pusher.push(connection.payload, event: connection.event)
+      loop! if pending?(connection.event)
+      pusher.push(nil, event: 'terminated')
+      pusher.close
+    rescue IOError
+      # The Fiber should die when it can't write to socket
+    end
+
+    def init!(connection)
+      @connection = connection
+      pusher.write_headers
+    end
+
+    def loop!
+      while Time.now.to_i < @connection.terminate_at
+        heartbeat!
+        event = Fiber.yield
+        next unless event
+
+        pusher.push(event[:data], event: event[:event])
+        @latest_heartbeat = Time.now.to_i
+        break if completed?(event[:event])
+      end
+    end
+
+    def completed?(event)
+      %w[completed failed].include?(event)
+    end
+
+    def pending?(event)
+      !completed?(event)
+    end
+
+    def heartbeat!
+      return unless Time.now.to_i > @latest_heartbeat + Pollen.server.configuration.heartbeat
+
+      pusher.comment
+      @latest_heartbeat = Time.now.to_i
+    end
+
+    def pusher
+      @pusher ||= Pusher.new(@connection.socket)
+    end
+  end
+end

data/lib/pollen/middleware.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Middleware
+    UUID_REGEXP = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+
+    def initialize(app)
+      @app = app
+      @server = Pollen.server
+      @route = @server.configuration.route_regexp
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      if @server.started? && (stream_id = request.path.match(@route)&.captures&.first)
+        raise 'Unable to hijack HTTP connection' unless env['rack.hijack?']
+
+        authenticate_and_hijack(request, env, stream_id)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def authenticate_and_hijack(request, env, stream_id)
+      load_stream(stream_id, request, env).tap do |stream|
+        @server.accept(env['rack.hijack'].call, stream)
+      end
+      [200, {}, []]
+    rescue Errors::AuthenticationFailure
+      [401, {}, []]
+    rescue Errors::StreamNotFound
+      [404, {}, []]
+    end
+
+    def authenticate_owner(stream_id, request, env)
+      authenticator.call(request, env).tap do |owner|
+        raise Errors::AuthenticationFailure, "Unable to authenticate user on stream #{stream_id}" if owner.nil?
+      end
+    end
+
+    def load_stream(stream_id, request, env)
+      Stream.find_by(owner: authenticate_owner(stream_id, request, env), id: stream_id).tap do |stream|
+        raise Errors::StreamNotFound, "Unable to find stream with ID #{stream_id}" if stream.nil?
+      end
+    end
+
+    def authenticator
+      Pollen.server.configuration.authenticator
+    end
+  end
+end

data/lib/pollen/partitioner.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Partitioner
+    attr_reader :concurrency
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def partition(uuid)
+      Digest::MD5.new.tap { |d| d.update uuid }.hexdigest[...2].to_i(16) % @configuration.concurrency
+    end
+  end
+end

data/lib/pollen/pusher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pollen
+  class IOError < StandardError; end
+
+  class Pusher
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def write_headers
+      socket_puts headers.join("\n")
+      socket_puts
+    end
+
+    def comment
+      write_chunk [':', "\n"].compact.join("\n")
+    end
+
+    def push(payload, event:)
+      write_chunk ["event:#{event}", payload ? "data:#{payload}" : nil, "\n"].compact.join("\n")
+    end
+
+    def close
+      write_last_chunk
+      socket_close
+    end
+
+    private
+
+    def write_chunk(data)
+      socket_puts [data.bytesize.to_s(16), data, ''].join("\r\n")
+    end
+
+    def write_last_chunk
+      socket_puts "0\r\n\r\n"
+    end
+
+    def headers
+      [
+        'HTTP/1.1 200',
+        'Content-Type: text/event-stream',
+        'Transfer-Encoding: chunked',
+        'X-Accel-Buffering: no',
+        'Cache-Control: no-cache'
+      ]
+    end
+
+    def socket_puts(data = nil)
+      @socket.puts data
+    rescue StandardError
+      raise IOError
+    end
+
+    def socket_close
+      @socket.close
+    rescue StandardError
+      raise IOError
+    end
+  end
+end

data/lib/pollen/server.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Pollen
+  class Executor
+    def initialize
+      @events = {}
+      @incoming = []
+      @mutex = Mutex.new
+      @event_loop = EventLoop.new
+    end
+
+    def start!
+      @thread = Thread.new do
+        start_loop
+      end
+      self
+    end
+
+    def push(stream_id, event, data)
+      Rails.logger.info "Pushing data for stream #{stream_id}, event: #{event}"
+      @mutex.synchronize do
+        @events[stream_id] = { event:, data: }
+      end
+    end
+
+    def accept(connection)
+      Rails.logger.info "Creating connection for stream #{connection.stream_id}"
+      @mutex.synchronize do
+        @incoming << connection
+      end
+    end
+
+    private
+
+    def start_loop
+      loop do
+        next_tick
+      end
+    end
+
+    def next_tick
+      incoming = nil
+      events = nil
+      @mutex.synchronize do
+        incoming = @incoming
+        events = @events
+        @events = {}
+        @incoming = []
+      end
+      proceed(incoming, events)
+    end
+
+    def proceed(incoming, events)
+      @event_loop.proceed(incoming, events).tap { sleep 0.01 }
+    end
+  end
+
+  class Server
+    include Configurable
+
+    def initialize
+      @partitioner = Partitioner.new(configuration)
+    end
+
+    def start!
+      @executors = Array.new(configuration.concurrency).map do
+        Executor.new.start!
+      end
+      Subscriber.new(self).start!
+      @started = true
+      self
+    end
+
+    def started?
+      !!@started
+    end
+
+    def push(stream_id, *args)
+      executor(stream_id).push(stream_id, *args)
+    end
+
+    def accept(socket, stream)
+      executor(stream.id).accept(
+        IncomingConnection.new(stream.id, socket, stream.status, stream.payload, Time.now.to_i + stream.timeout)
+      )
+    end
+
+    def configuration
+      return @configuration if @configuration
+
+      @configuration = CompositeConfiguration.new(
+        ServerConfiguration.new,
+        Pollen.common.configuration
+      )
+    end
+
+    private
+
+    def executor(stream_id)
+      @executors[@partitioner.partition(stream_id)]
+    end
+  end
+end

data/lib/pollen/subscriber.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+module Pollen
+  class Subscriber
+    def initialize(server)
+      @server = server
+    end
+
+    def start!
+      if redis.nil?
+        raise Errors::InvalidConfiguration,
+              'Redis not set, please assign a Redis client in server configuration'
+      end
+
+      Thread.new { subscribe! }
+    end
+
+    private
+
+    def subscribe!
+      redis.psubscribe("#{channel_prefix}:*") do |on|
+        on.pmessage do |_, channel, message|
+          event, data = message.split(':', 2)
+          stream_id = stream_id_from_channel(channel)
+          @server.push(stream_id, event, data) unless stream_id.blank? || event.blank?
+        end
+      end
+    end
+
+    def stream_id_from_channel(channel)
+      /^#{channel_prefix}:(#{ServerConfiguration::UUID_REGEXP})/.match(channel)&.captures&.first
+    end
+
+    def channel_prefix
+      @channel_prefix ||= Pollen.server.configuration.channel_prefix
+    end
+
+    def redis
+      @redis ||= @server.configuration.redis
+    end
+  end
+end

data/lib/pollen/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pollen
+  VERSION = '0.1.0'
+end

data/lib/pollen.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'pollen/commands'
+require 'pollen/configuration'
+require 'pollen/event_loop'
+require 'pollen/errors'
+require 'pollen/fiber_body'
+require 'pollen/partitioner'
+require 'pollen/pusher'
+
+require 'pollen/subscriber'
+require 'pollen/controller'
+require 'pollen/middleware'
+require 'pollen/server'
+require 'pollen/engine'
+
+module Pollen
+  class IncomingConnection
+    attr_reader :stream_id, :socket, :event, :payload, :terminate_at
+
+    def initialize(stream_id, socket, event, payload, terminate_at)
+      @stream_id = stream_id
+      @socket = socket
+      @event = event
+      @payload = payload
+      @terminate_at = terminate_at
+    end
+  end
+
+  class << self
+    def server
+      @server ||= Server.new
+    end
+
+    def controller
+      @controller ||= Controller.new
+    end
+
+    def common
+      @common ||= Common.new
+    end
+  end
+end

data/lib/tasks/pollen_tasks.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+namespace :pollen do
+  task prune_streams: :environment do
+    scope = Pollen::Stream.where('created_at <= :time', time: Time.zone.now - Pollen.controller.configuration.retention)
+    scope.count.tap do |count|
+      scope.delete_all
+      puts "Pruned #{count} old streams"
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: pollen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jef Mathiot
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An HTTP Pub/Sub engine for Rails.
+email:
+- jeff.mathiot@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/models/pollen/application_record.rb
+- app/models/pollen/stream.rb
+- db/migrate/20241125150719_create_pollen_streams.rb
+- lib/pollen.rb
+- lib/pollen/commands.rb
+- lib/pollen/configuration.rb
+- lib/pollen/controller.rb
+- lib/pollen/engine.rb
+- lib/pollen/errors.rb
+- lib/pollen/event_loop.rb
+- lib/pollen/fiber_body.rb
+- lib/pollen/middleware.rb
+- lib/pollen/partitioner.rb
+- lib/pollen/pusher.rb
+- lib/pollen/server.rb
+- lib/pollen/subscriber.rb
+- lib/pollen/version.rb
+- lib/tasks/pollen_tasks.rake
+homepage: https://github.com/everestHC-mySofie/pollen
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/everestHC-mySofie/pollen
+  source_code_uri: https://github.com/everestHC-mySofie/pollen
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: An HTTP Pub/Sub engine for Rails.
+test_files: []