celluloid-io-pg-listener 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce318ab56811980419529ad908744fb7fbdb4d98
-  data.tar.gz: a9c80bee87a9d8590d58a6c74392ddb703ce8741
+  metadata.gz: ddc37be5e4eee1abe1413ff3575d48bf00f81b85
+  data.tar.gz: 84dc1911a7312843afe56a6aa77e692bc5ccf884
 SHA512:
-  metadata.gz: 2cbd4af5d91032b865d410ac8fba9377532f698c548437cf5adbefb9a53c2c493008921fa5df253b45f119d8f33ab004cce387a5d42a35354ef070b81b327c4f
-  data.tar.gz: b6f55bf9e26766cfa7313f1fd9718be8dc60ed58962c279b153f4a188aa56da3dec76a51903873dabbd5491870c644192573868fa7bf1b650f8787bde36754f7
+  metadata.gz: 5a1a385fac178dd4fa8210e309fcdc3905ad7c3e4265c1928a295d216756e79112685223aed0b68d57768605c978a75eef8be783df2a4aafdcde8529e9bd9288
+  data.tar.gz: 288ef59b324245f917cd33778f95b3b68e6e8fb027142a75f71b783d60847258070aeb73b4eb9e7880870e96a9cbad10cd1cd9f0419147db03147416d21d28c5

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 cache: bundler
 rvm:
+  - 2.0.0
   - 2.1.5
   - 2.2.3
 before_install:

data/README.md

@@ -51,6 +51,20 @@ Or install it yourself as:
 
     $ gem install celluloid-io-pg-listener
 
+## Upgrading 0.2.x to 0.3.x
+
+Change:
+```
+include CelluloidIOPGListener::Client
+```
+To:
+```
+include CelluloidIOPGListener.client(:unlisten_wrapper_with_termination)
+```
+You now have a choice of unlisten wrappers, with or without termination as part of the unlisten.
+The one without terminate is used with you are running a client inside a celluloid supervisor container, which handles termination.
+See `bin/supervisor` and `bin/supervision` in this project for two examples of this.
+
 ## Usage
 
 Find a data base that exists that you want to run notifications through.  Won't affect anything else in the database,
@@ -61,21 +75,7 @@ In an irb session taking care to:
 - replace the database names with your own
 - replace the channel name, if you want, they are arbitrary, and don't need to be "created" in the DB.
 
-First load the examples (they are not loaded by default):
-```ruby
->> require "celluloid-io-pg-listener"
-=> true
->> require "celluloid-io-pg-listener/examples/client"
-=> true
->> require "celluloid-io-pg-listener/examples/server"
-=> true
->> require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
-=> true
->> require "celluloid-io-pg-listener/examples/notify_server_by_inheritance"
-=> true
-```
-
-Then turn on debug mode to see what is happening:
+Turn on debug mode to see what is happening:
 ```
 >> $CELLULOID_DEBUG=true
 => true
@@ -151,7 +151,7 @@ module CelluloidIOPGListener
   module Examples
     class Client
 
-      include CelluloidIOPGListener::Client
+      include CelluloidIOPGListener.client(:unlisten_wrapper_with_termination)
 
       # Defining initialize is optional,
       #   unless you have custom args you need to handle

data/bin/console

@@ -2,6 +2,12 @@
 
 require "bundler/setup"
 require "celluloid-io-pg-listener"
+# Load the examples to make it easy to play
+require "celluloid-io-pg-listener/examples/client"
+require "celluloid-io-pg-listener/examples/double_super_example"
+require "celluloid-io-pg-listener/examples/server"
+require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
+require "celluloid-io-pg-listener/examples/notify_server_by_inheritance"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/bin/settings.multiple.yml

@@ -0,0 +1,25 @@
+listening_group:
+-
+  listener_active: true
+  type: CelluloidIOPGListener::Examples::Client
+  as: insert_client1
+  args:
+    dbname: "celluloid_io_pg_listener_test"
+    callback_method: insert_callback
+    channel: "users_insert"
+-
+  listener_active: true
+  type: CelluloidIOPGListener::Examples::ListenerClientByInheritance
+  as: insert_client2
+  args:
+    dbname: "celluloid_io_pg_listener_test"
+    callback_method: foo_bar
+    channel: "users_insert"
+-
+  listener_active: true
+  type: CelluloidIOPGListener::InsertClient
+  as: insert_client3
+  args:
+    dbname: "celluloid_io_pg_listener_test"
+    callback_method: insert_callback
+    channel: "users_insert"

data/bin/settings.yml

@@ -0,0 +1,9 @@
+listening_group:
+-
+  listener_active: true
+  type: CelluloidIOPGListener::InsertClient
+  as: insert_client
+  args:
+    dbname: "celluloid_io_pg_listener_test"
+    callback_method: insert_callback
+    channel: "users_insert"

data/bin/supervision

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# Run the supervisor from a command prompt like this:
+#
+#    bin/supervision --config bin/settings.yml &
+#
+require "erb"
+require "uri"
+require "yaml"
+require "optparse"
+require "bundler/setup"
+require "celluloid/current"
+require "celluloid/supervision"
+require "celluloid-io-pg-listener"
+require "celluloid-io-pg-listener/supervision_configuration_signature"
+
+# These are referenced in bin/settings.yml, so they have to be required:
+require "celluloid-io-pg-listener/examples/client"
+require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
+
+$supervisor_options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: bin/supervisor [options]"
+
+  opts.on("-c", "--config FILE", "Path to YAML configuration file") do |file|
+    $supervisor_options[:config_path] = file
+  end
+  opts.on("-d", "--debug", "set $CELLULOID_DEBUG = true") do |file|
+    $supervisor_options[:debug] = true
+    $CELLULOID_DEBUG = true
+  end
+  opts.on("-t", "--threaded", "set Celluloid.task_class = Celluloid::Task::Threaded") do |file|
+    $supervisor_options[:threaded] = true
+    Celluloid.task_class = Celluloid::Task::Threaded
+  end
+end.parse!
+puts "$supervisor_options: #{$supervisor_options.inspect}" if $supervisor_options[:debug]
+
+module CelluloidIOPGListener
+  class InsertClient
+    include CelluloidIOPGListener.client(:unlisten_wrapper_without_termination)
+    def insert_callback(channel, payload)
+      # <-- within the unlisten_wrapper's block if :insert_callback is the callback_method
+      debug "#{self.class} channel is #{channel}"
+      debug "#{self.class} payload is #{payload}"
+    end
+  end
+end
+
+class ListeningGroup < Celluloid::Supervision::Container
+  supervise type: CelluloidIOPGListener::InsertClient, as: :insert_client, args: [{dbname: "celluloid_io_pg_listener_test", channel: "users_insert", callback_method: :insert_callback}]
+end
+
+# Alternatively:
+# class ListeningGroup < Celluloid::Supervision::Container
+#   signature = CelluloidIOPGListener::SupervisionConfigurationSignature.new(path_to_yaml: $supervisor_options[:config_path]).signature.first
+#   supervise **signature
+# end
+
+ListeningGroup.run
+

data/bin/supervisor

@@ -1,16 +1,43 @@
 #!/usr/bin/env ruby
 # Run the supervisor from a command prompt like this:
 #
-#    bin/supervisor &
+#    bin/supervisor --config bin/settings.multiple.yml &
 #
+require "erb"
+require "uri"
+require "yaml"
+require "optparse"
 require "bundler/setup"
 require "celluloid/current"
 require "celluloid/supervision"
 require "celluloid-io-pg-listener"
+require "celluloid-io-pg-listener/supervision_configuration_signature"
+
+# These are referenced in bin/settings.yml, so they have to be required:
+require "celluloid-io-pg-listener/examples/client"
+require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
+
+$supervisor_options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: bin/supervisor [options]"
+
+  opts.on("-c", "--config FILE", "Path to YAML configuration file") do |file|
+    $supervisor_options[:config_path] = file
+  end
+  opts.on("-d", "--debug", "set $CELLULOID_DEBUG = true") do |file|
+    $supervisor_options[:debug] = true
+    $CELLULOID_DEBUG = true
+  end
+  opts.on("-t", "--threaded", "set Celluloid.task_class = Celluloid::Task::Threaded") do |file|
+    $supervisor_options[:threaded] = true
+    Celluloid.task_class = Celluloid::Task::Threaded
+  end
+end.parse!
+puts "$supervisor_options: #{$supervisor_options.inspect}" if $supervisor_options[:debug]
 
 module CelluloidIOPGListener
   class InsertClient
-    include CelluloidIOPGListener::Client
+    include CelluloidIOPGListener.client(:unlisten_wrapper_without_termination)
     def insert_callback(channel, payload)
       # <-- within the unlisten_wrapper's block if :insert_callback is the callback_method
       debug "#{self.class} channel is #{channel}"
@@ -18,8 +45,17 @@ module CelluloidIOPGListener
     end
   end
 end
-# TODO: Update DB Connection to default to Heroku DB Connection URL, with the salesforce schema, then fallback to celluloid-io-pg-listener_test
+
 class ListeningGroup < Celluloid::Supervision::Container
-  supervise type: CelluloidIOPGListener::InsertClient, as: :insert_client, args: [{dbname: "celluloid_io_pg_listener_test", channel: "users_insert", callback_method: :insert_callback}]
+  signatures = CelluloidIOPGListener::SupervisionConfigurationSignature.new(path_to_yaml: $supervisor_options[:config_path]).signature
+  supervise **signatures[0] if signatures[0]
+  supervise **signatures[1] if signatures[1]
+  supervise **signatures[2] if signatures[2]
 end
+
 ListeningGroup.run
+
+# Not sure why this is not working
+# config_signature = CelluloidIOPGListener::SupervisionConfigurationSignature.new(path_to_yaml: $supervisor_options[:config_path]).signature
+# supervision_config = Celluloid::Supervision::Configuration.define(config_signature)
+# supervision_config.deploy

data/lib/celluloid-io-pg-listener.rb

@@ -4,14 +4,49 @@ require "celluloid/io"
 require "pg"
 
 # Define the namespace this gem uses
-module CelluloidIOPGListener; end
+module CelluloidIOPGListener
+
+  # Redefining this constant would allow you to set whatever unlisten wrapper you want
+  UNLISTEN_WRAPPER_TYPE = {
+      unlisten_wrapper_with_termination: "CelluloidIOPGListener::UnlistenWrappers::WithTermination",
+      unlisten_wrapper_without_termination: "CelluloidIOPGListener::UnlistenWrappers::WithoutTermination"
+  }
+
+  # Returns a module
+  # Usage:
+  #
+  #   class MyClient
+  #     include CelluloidIOPGListener.client(:unlisten_wrapper_with_termination) # with no argument this is default
+  #   end
+  #
+  # For a Client that will be used inside a SupervisorContainer you want to let the Supervisor handle termination.
+  #   At least that's my operating hypothesis, if anyone knows better please let me know.
+  #
+  #   class MyClient
+  #     include CelluloidIOPGListener.client(:unlisten_wrapper_without_termination)
+  #   end
+  #
+  def self.client(unlisten_wrapper_type = :unlisten_wrapper_with_termination)
+    wrapper = UNLISTEN_WRAPPER_TYPE[unlisten_wrapper_type]
+    puts "unlisten wrapper: #{wrapper},\nunlisten_wrapper_type: #{unlisten_wrapper_type},\ncaller: #{caller.first}"
+    Kernel.const_get(wrapper)
+  end
+
+end
 
 require "celluloid-io-pg-listener/initialization/client_extracted_signature"
 require "celluloid-io-pg-listener/initialization/argument_extraction"
 require "celluloid-io-pg-listener/initialization/async_listener"
 require "celluloid-io-pg-listener/client"
+require "celluloid-io-pg-listener/unlisten_wrappers/with_termination"
+require "celluloid-io-pg-listener/unlisten_wrappers/without_termination"
+
+# Require in your executable script that runs your supervisor.  See bin/supervisor as an example.
+# require "celluloid-io-pg-listener/supervision_configuration_signature"
+
 # Require manually, as in bin/console, if you want to try them out.
 # require "celluloid-io-pg-listener/examples/client"
+# require "celluloid-io-pg-listener/examples/double_super_example"
 # require "celluloid-io-pg-listener/examples/server"
 # require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
 # require "celluloid-io-pg-listener/examples/notify_server_by_inheritance"

data/lib/celluloid-io-pg-listener/client.rb

@@ -25,21 +25,6 @@ module CelluloidIOPGListener
     def initialize(*args)
     end
 
-    def unlisten_wrapper(channel, payload, &block)
-      if block_given?
-        debug "Acting on payload: #{payload} on #{channel}"
-        instance_eval(&block)
-      else
-        info "Not acting on payload: #{payload} on #{channel}"
-      end
-    rescue => e
-      info "#{self.class}##{callback_method} disconnected from #{channel} via #{e.class} #{e.message}"
-      unlisten(channel)
-      terminate
-      # Rescue the error in a daemon-error-reporter to send to Airbrake or other reporting service?
-      raise
-    end
-
     def actions
       @actions ||= {}
     end
@@ -86,11 +71,5 @@ module CelluloidIOPGListener
       end
     end
 
-    def unlisten(channel)
-      # (@listening ||= {})[channel] = false
-      stop_listening # Not sure if there is a way to stop listening to a single channel without affecting the others.
-      pg_connection.exec(%[UNLISTEN "#{channel}";])
-    end
-
   end
 end

data/lib/celluloid-io-pg-listener/examples/client.rb

@@ -2,7 +2,7 @@ module CelluloidIOPGListener
   module Examples
     class Client
 
-      include CelluloidIOPGListener::Client
+      include CelluloidIOPGListener.client(:unlisten_wrapper_with_termination)
 
       attr_reader :optional_arg
       # Defining initialize is optional,

data/lib/celluloid-io-pg-listener/initialization/async_listener.rb

@@ -44,7 +44,11 @@ module CelluloidIOPGListener
               super(channel, payload)
             else
               error "LISTENER ERROR: #{payload}"
-              raise CelluloidIOPGListener::Client::InvalidClient, "#{self.class} does not define a method :#{@callback_method} with arguments (channel, payload)"
+              if callback_method == :unlisten_wrapper
+                raise CelluloidIOPGListener::Client::InvalidClient, "Please specify a callback_method with signature (channel, payload) to be called on an instance of #{self.class}"
+              else
+                raise CelluloidIOPGListener::Client::InvalidClient, "#{self.class} does not define a method :#{callback_method} with signature (channel, payload)"
+              end
             end
           end
         end

data/lib/celluloid-io-pg-listener/supervise_signature.rb

@@ -0,0 +1,86 @@
+module CelluloidIOPGListener
+  # Usage:
+  #
+  #   Given a yaml config file of this format:
+  #
+  #     listening_group:
+  #     -
+  #       listener_active: <%= ENV["LISTENER_ACTIVE"] || false %>
+  #       type: HerokuConnectListener::SalesforceAccountClient
+  #       as: insert_client
+  #       args:
+  #         database_url: <%= ENV["DATABASE_URL"] %>
+  #           redis_url: <%= ENV["REDISTOGO_URL"] || "redis://localhost:6379/" %>
+  #         callback_method: notify_callback
+  #         channel: <%= ENV["SCHEMA_NAME"] %>_account_insert
+  #
+  #   Create a Supervision Container such as:
+  #
+  #     class ListeningGroup < Celluloid::Supervision::Container
+  #       config_path = options[:config_path] || "config/settings.yml"
+  #       config      = YAML::load(ERB.new(File.read(config_path)).result)
+  #       supervise CelluloidIOPGListener::SuperviseSignature.new(
+  #                     type: config["type"],
+  #                     as: config["as"],
+  #                     args: config["args"]
+  #                 ).signature
+  #     end
+  #
+  #     ListeningGroup.run
+  #
+  class SuperviseSignature
+    KEYS_WITH_SYMBOL_VALUES = %( callback_method )
+    attr_reader :type
+    attr_reader :as
+    attr_reader :args
+
+    def initialize(type:, as:, args:)
+      @type = Kernel.const_get(type)
+      @as = as.to_sym
+      if has_database_url?(args)
+        args.merge!(convert_database_url_to_hash(db_url: args.delete("database_url")))
+      end
+      @args = []
+      @args << symbolize_keys(args)
+    end
+
+    def signature
+      {
+          type: type,
+          as: as,
+          args: args
+      }
+    end
+
+    private
+
+    def symbolize_key(key, value, hash)
+      if KEYS_WITH_SYMBOL_VALUES.include?(key)
+        hash[key.to_sym] = value.to_sym
+      else
+        hash[key.to_sym] = value
+      end
+    end
+    def symbolize_keys(args)
+      args.inject({}) do |memo, (key, value)|
+        symbolize_key(key, value, memo)
+        memo
+      end
+    end
+    def has_database_url?(args)
+      args.is_a?(Hash) && !args["database_url"].nil?
+    end
+
+    # returns a hash of connection info extracted from the database url (as on Heroku)
+    def convert_database_url_to_hash(db_url:)
+      uri = URI.parse(db_url)
+      connection_info = {}
+      connection_info["dbname"]   = (uri.path || "").split("/")[1]
+      connection_info["user"]     = uri.user
+      connection_info["password"] = uri.password
+      connection_info["host"]     = uri.host
+      connection_info["port"]     = uri.port
+      connection_info
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/supervision_configuration_signature.rb

@@ -0,0 +1,68 @@
+require "celluloid-io-pg-listener/supervise_signature"
+
+module CelluloidIOPGListener
+  #
+  # Usage:
+  #
+  #     config_path = options[:config_path] || "config/settings.yml"
+  #     config_signature = CelluloidIOPGListener::SupervisionConfigurationSignature.new(path_to_yaml: config_path).signature
+  #     supervision_config = Celluloid::Supervision::Configuration.define(*config_signature)
+  #     supervision_config.deploy
+  #
+  class SupervisionConfigurationSignature
+    include Celluloid::Internals::Logger
+
+    attr_reader :yaml_config
+    attr_reader :supervision_config
+
+    def initialize(path_to_yaml: nil, yaml_hash: nil)
+      @yaml_config = yaml_hash || YAML::load(ERB.new(File.read(path_to_yaml)).result)
+      # config may be the whole yaml / hash, or it may be nested.
+      # If nested it is value of the key "listening_group".
+      @yaml_config = @yaml_config["listening_group"] if @yaml_config["listening_group"]
+      unless @yaml_config.nil?
+        @yaml_config = @yaml_config.dup # Don't want to mutate anything that was passed in
+        @supervision_config = process_yaml_config
+      end
+    end
+
+    # Returns an array like this:
+    #   [
+    #     {
+    #         type: MyActor,
+    #         as: :my_actor,
+    #         args: []
+    #     },
+    #     {
+    #         type: MyActor,
+    #         as: :my_actor_with_args,
+    #         args: [
+    #                 :one_arg,
+    #                 :two_args
+    #               ]
+    #     },
+    #   ]
+    def signature
+      supervision_config
+    end
+
+    private
+
+    def process_yaml_config
+      yaml_config.inject([]) do |config_array, listener_config|
+        debug "listener_config: #{listener_config}"
+        if listener_config.delete("listener_active")
+          config_array << CelluloidIOPGListener::SuperviseSignature.new(
+              type: listener_config["type"],
+              as: listener_config["as"],
+              args: listener_config["args"]
+          ).signature
+          info "Listening to channel '#{listener_config["args"]["channel"]}' on database '#{listener_config["args"]["dbname"]}'..."
+        else
+          info "Listener not active for channel '#{listener_config["args"]["channel"]}' on database '#{listener_config["args"]["dbname"]}'..."
+        end
+        config_array
+      end
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/unlisten_wrappers/with_termination.rb

@@ -0,0 +1,30 @@
+module CelluloidIOPGListener
+  module UnlistenWrappers
+    module WithTermination
+
+      def self.included(base)
+        base.send(:include, CelluloidIOPGListener::Client)
+      end
+
+      def unlisten_wrapper(channel, payload, &block)
+        if block_given?
+          debug "Acting on payload: #{payload} on #{channel}"
+          instance_eval(&block)
+        else
+          info "Not acting on payload: #{payload} on #{channel}"
+        end
+      rescue => e
+        info "#{self.class}##{callback_method} disconnected from #{channel} via #{e.class} #{e.message}"
+        unlisten(channel)
+        terminate
+        raise
+      end
+
+      def unlisten(channel)
+        stop_listening
+        pg_connection.exec(%[UNLISTEN "#{channel}";])
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/unlisten_wrappers/without_termination.rb

@@ -0,0 +1,30 @@
+module CelluloidIOPGListener
+  module UnlistenWrappers
+    # When running in a Supervision::Container we don't need the terminate.
+    module WithoutTermination
+
+      def self.included(base)
+        base.send(:include, CelluloidIOPGListener::Client)
+      end
+
+      def unlisten_wrapper(channel, payload, &block)
+        if block_given?
+          debug "Acting on payload: #{payload} on #{channel}"
+          instance_eval(&block)
+        else
+          info "Not acting on payload: #{payload} on #{channel}"
+        end
+      rescue => e
+        info "#{self.class}##{callback_method} disconnected from #{channel} via #{e.class} #{e.message}"
+        unlisten(channel)
+        raise
+      end
+
+      def unlisten(channel)
+        stop_listening
+        pg_connection.exec(%[UNLISTEN "#{channel}";])
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/version.rb

@@ -1,3 +1,3 @@
 module CelluloidIOPGListener
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io-pg-listener
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-24 00:00:00.000000000 Z
+date: 2015-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -183,8 +183,11 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/settings.multiple.yml
+- bin/settings.yml
 - bin/setup
 - bin/setup.sql
+- bin/supervision
 - bin/supervisor
 - celluloid-io-pg-listener.gemspec
 - gemfiles/rails_3.2.22.gemfile
@@ -201,6 +204,10 @@ files:
 - lib/celluloid-io-pg-listener/initialization/argument_extraction.rb
 - lib/celluloid-io-pg-listener/initialization/async_listener.rb
 - lib/celluloid-io-pg-listener/initialization/client_extracted_signature.rb
+- lib/celluloid-io-pg-listener/supervise_signature.rb
+- lib/celluloid-io-pg-listener/supervision_configuration_signature.rb
+- lib/celluloid-io-pg-listener/unlisten_wrappers/with_termination.rb
+- lib/celluloid-io-pg-listener/unlisten_wrappers/without_termination.rb
 - lib/celluloid-io-pg-listener/version.rb
 homepage: https://github.com/pboling/celluloid-io-pg-listener
 licenses: