subserver 0.1.0

data/lib/subserver/message_logger.rb

@@ -0,0 +1,24 @@
+module Subserver
+  class MessageLogger
+
+    def call(message)
+      start = Time.now
+      logger.info("start")
+      yield
+      logger.info("done: #{elapsed(start)} sec")
+    rescue Exception
+      logger.info("fail: #{elapsed(start)} sec")
+      raise
+    end
+
+    private
+
+    def elapsed(start)
+      (Time.now - start).round(3)
+    end
+
+    def logger
+      Subserver.logger
+    end
+  end
+end

data/lib/subserver/middleware/active_record.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Subserver
+  module Middleware
+    class ActiveRecord
+
+      def initialize
+        # With Rails 5+ we must use the Reloader **always**.
+        # The reloader handles code loading and db connection management.
+        if defined?(::Rails) && ::Rails::VERSION::MAJOR >= 5
+          raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
+        end
+      end
+
+      def call(*args)
+        yield
+      ensure
+        ::ActiveRecord::Base.clear_active_connections!
+      end
+    end
+  end
+end

data/lib/subserver/middleware/chain.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module Subserver
+  # Middleware is code configured to run before/after
+  # a message is processed.  It is patterned after Rack
+  # middleware. 
+  #
+  # To modify middleware for the server, just call
+  # with another block:
+  #
+  # Subserver.configure do |config|
+  #   config.middleware do |chain|
+  #     chain.add MyServerHook
+  #     chain.remove ActiveRecord
+  #   end
+  # end
+  #
+  # To insert immediately preceding another entry:
+  #
+  # Subserver.configure do |config|
+  #   config.middleware do |chain|
+  #     chain.insert_before ActiveRecord, MyServerHook
+  #   end
+  # end
+  #
+  # To insert immediately after another entry:
+  #
+  # Subserver.configure do |config|
+  #   config.middleware do |chain|
+  #     chain.insert_after ActiveRecord, MyServerHook
+  #   end
+  # end
+  #
+  # This is an example of a minimal server middleware:
+  #
+  # class MyServerHook
+  #   def call(subscriber_class, message)
+  #     puts "Before work"
+  #     yield
+  #     puts "After work"
+  #   end
+  # end
+  #
+  #
+  module Middleware
+    class Chain
+      include Enumerable
+      attr_reader :entries
+
+      def initialize_copy(copy)
+        copy.instance_variable_set(:@entries, entries.dup)
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def initialize
+        @entries = []
+        yield self if block_given?
+      end
+
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i+1, new_entry)
+      end
+
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      def retrieve
+        map(&:make_new)
+      end
+
+      def clear
+        entries.clear
+      end
+
+      def invoke(*args)
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    class Entry
+      attr_reader :klass
+
+      def initialize(klass, *args)
+        @klass = klass
+        @args  = args
+      end
+
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end

data/lib/subserver/pubsub.rb

@@ -0,0 +1,20 @@
+require "google/cloud/pubsub"
+
+module Subserver
+  module Pubsub
+    def self.client
+      defined?(@client) ? @client : initialize_client
+    end
+
+    def self.initialize_client
+      @client = Google::Cloud::Pubsub.new(
+        project_id: options[:project_id],
+        credentials: File.expand_path(options[:credentials])
+      )
+    end
+
+    def self.options
+      Subserver.options
+    end
+  end
+end

data/lib/subserver/rails.rb

@@ -0,0 +1,57 @@
+module Subserver
+  class Rails < ::Rails::Engine
+    # We need to setup this up before any application configuration which might
+    # change Subserver middleware.
+    #
+    # This hook happens after `Rails::Application` is inherited within
+    # config/application.rb and before config is touched, usually within the
+    # class block. Definitely before config/environments/*.rb and
+    # config/initializers/*.rb.
+    config.before_configuration do
+      if ::Rails::VERSION::MAJOR < 5 && defined?(::ActiveRecord)
+        Subserver.middleware do |chain|
+          require 'subserver/middleware/active_record'
+          chain.add Subserver::Middleware::ActiveRecord
+        end
+      end
+    end
+
+    config.after_initialize do
+      # This hook happens after all initializers are run, just before returning
+      # from config/environment.rb back to subserver/cli.rb.
+      # We have to add the reloader after initialize to see if cache_classes has
+      # been turned on.
+      #
+      Subserver.configure do |_|
+
+        Subserver.options[:subscriber_dir] = ::Rails.root.join('app', 'subscribers')
+
+        if ::Rails::VERSION::MAJOR >= 5
+          Subserver.options[:reloader] = Subserver::Rails::Reloader.new
+        end
+      end
+    end
+
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<Subserver::Rails::Reloader @app=#{@app.class.name}>"
+      end
+    end
+  end if defined?(::Rails)
+end
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR < 4
+  $stderr.puts("**************************************************")
+  $stderr.puts("WARNING: Subserver is not supported on Rails < 4. Please Update to a newer version of Rails.")
+  $stderr.puts("**************************************************")
+end

data/lib/subserver/subscriber.rb

@@ -0,0 +1,25 @@
+module Subserver
+  module Subscriber
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def logger
+      Subserver.logger
+    end
+
+    module ClassMethods
+      @subserver_options
+
+      def subserver_options(opts={})
+        (@subserver_options ||= Subserver.default_subscriber_options).merge!(opts)
+      end
+
+      def get_subserver_options
+        @subserver_options
+      end 
+    end
+
+  end
+end

data/lib/subserver/util.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'socket'
+require 'securerandom'
+require 'subserver/exception_handler'
+
+module Subserver
+  ##
+  # This module is part of Subserver core and not intended for extensions.
+  #
+  module Util
+    include ExceptionHandler
+
+    EXPIRY = 60 * 60 * 24
+
+    def watchdog(last_words)
+      yield
+    rescue Exception => ex
+      handle_exception(ex, { context: last_words })
+      raise ex
+    end
+
+    def safe_thread(name, &block)
+      Thread.new do
+        Thread.current['subserver_label'] = name
+        watchdog(name, &block)
+      end
+    end
+
+    def logger
+      Subserver.logger
+    end
+
+    def hostname
+      ENV['DYNO'] || Socket.gethostname
+    end
+
+    def process_nonce
+      @@process_nonce ||= SecureRandom.hex(6)
+    end
+
+    def identity
+      @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
+    end
+
+    def fire_event(event, options={})
+      reverse = options[:reverse]
+      reraise = options[:reraise]
+
+      arr = Subserver.options[:lifecycle_events][event]
+      arr.reverse! if reverse
+      arr.each do |block|
+        begin
+          block.call
+        rescue => ex
+          handle_exception(ex, { context: "Exception during Subserver lifecycle event.", event: event })
+          raise ex if reraise
+        end
+      end
+      arr.clear
+    end
+  end
+end

data/lib/subserver/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Subserver
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: subserver
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scott Hill
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-cloud-pubsub
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+description: Subserver is a background server process for processing messages from
+  Google Pub/Sub.
+email: 
+executables:
+- subserver
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- bin/subserver
+- lib/subserver.rb
+- lib/subserver/cli.rb
+- lib/subserver/exception_handler.rb
+- lib/subserver/health.rb
+- lib/subserver/launcher.rb
+- lib/subserver/listener.rb
+- lib/subserver/logging.rb
+- lib/subserver/manager.rb
+- lib/subserver/message_logger.rb
+- lib/subserver/middleware/active_record.rb
+- lib/subserver/middleware/chain.rb
+- lib/subserver/pubsub.rb
+- lib/subserver/rails.rb
+- lib/subserver/subscriber.rb
+- lib/subserver/util.rb
+- lib/subserver/version.rb
+homepage: https://github.com/lifechurch/subserver/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Simple background server process for Google Pub/Sub.
+test_files: []