pushyd 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f1475888d98b181ea4d70fbd0568a1ea73b900a
-  data.tar.gz: a4f3e851e8d8698084e480a2ea94c2fd1040d5dc
+  metadata.gz: 838aaf0ca927c20acf4d53714ff5eaa11499716a
+  data.tar.gz: e481c674723737cf9b8b6f84b38e57c8e6b39804
 SHA512:
-  metadata.gz: 507f389e40d4d80de6f4db4ed61c526d644cc0c0bdce04b21565c3507289421f0bda9d650f6dd4cfb3b3f9e6ebe0d491a6410781bd18de1b34fd8d9160a30375
-  data.tar.gz: c999e4e4bb98169092434000ceaa5aaf6facb2be792123ae56170458b732de78d2351c30883fabdd4f7ef5eb4fd45b776b823986546cc0811ea961b9d5c1f0c3
+  metadata.gz: e7cad3480998b54851e30573b0e1f8229c9c2ccd50359436b11b236ccccbd6fc2817e7a7bcecbcedbff0538366efa5814c61aeefccedc3d1d2408c2e07104fcb
+  data.tar.gz: 37cc4b0233a4da19f28d3c2a52cce679e4e12129b282bdb3d514ceee0a1ee5dac3a40b051bb5f783f20aee425eab2a0fa4b06003234030ad037e16dec4fe9813

data/Gemfile

@@ -1,3 +1,3 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pushyd (0.0.2)
+    pushyd (0.1.1)
       bunny
       chamber
       daemons
@@ -10,14 +10,14 @@ PATH
       terminal-table
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
     addressable (2.4.0)
     amq-protocol (2.0.1)
     ast (2.2.0)
     astrolabe (1.3.1)
       parser (~> 2.2)
-    bunny (2.2.2)
+    bunny (2.3.1)
       amq-protocol (>= 2.0.1)
     chamber (2.9.0)
       hashie (~> 3.3)

data/bin/pushyd.rb

@@ -10,15 +10,18 @@ begin
 rescue LoadError
   raise "EXITING: some basic libs were not found"
 end
+include PushyDaemon
 
-# Guess app root
-APP_ROOT = File.expand_path(File.dirname(__FILE__) + "/../")
 
-# Parse options and check compliance
-cmd_config = nil
-cmd_env = "production"
-cmd_dump = false
+# Handle configuration
+APP_ROOT = File.expand_path(File.dirname(__FILE__) + "/../")
 begin
+  # Defaults
+  cmd_config = nil
+  cmd_env = "production"
+  cmd_dump = false
+
+  # Parse options and check compliance
   OptionParser.new do |opts|
     opts.banner = "Usage: #{File.basename $PROGRAM_NAME} [options] start|stop"
     opts.on("-c", "--config CONFIGFILE")     { |config| cmd_config = File.expand_path(config)}
@@ -26,21 +29,25 @@ begin
     opts.on("-d", "--dump")                  { cmd_dump = true }
     opts.on("",   "--dev")                   { cmd_env = "development" }
   end.order!(ARGV)
-rescue OptionParser::InvalidOption => e
-  abort "EXITING: option parser: #{e.message}"
-end
 
+  # Build Chamber-based configuration from Gemspec with initial context
+  Config.prepare root: APP_ROOT, gemspec: "pushyd", env: cmd_env, config: cmd_config
 
-# Build Chamber-based configuration from Gemspec with initial context
-Config.prepare root: APP_ROOT, gemspec: "pushyd", env: cmd_env, config: cmd_config
+  # Display final configuration
+  puts "--- #{Config.name} #{Config.version}"
+  puts "Environment    \t #{Config.env}"
+  puts "Config files   \t #{Config.files}"
+  puts
+  puts "Log file       \t #{Config[:log]}"
+  puts Config.dump if cmd_dump
 
-# Display final configuration
-puts "--- #{Config.name} #{Config.version}"
-puts "Environment    \t #{Config.env}"
-puts "Config files   \t #{Config.files}"
-puts
-puts "Log file       \t #{Config[:log]}"
-puts Config.dump if cmd_dump
+rescue OptionParser::InvalidOption => e
+  abort "EXITING: option parser: #{e.message}"
+rescue PushyDaemon::ConfigParseError => e
+  abort "EXITING: ConfigParseError: #{e.message}"
+rescue Exception => e
+  abort "EXITING: Exception: #{e.message}"
+end
 
 
 # Run daemon

data/lib/pushyd/config.rb

@@ -1,43 +1,59 @@
 require "chamber"
 
-class Config
-  extend Chamber
-
-  class << self
-    attr_reader :name
-    attr_reader :spec
-    attr_reader :files
-    attr_reader :version
-    attr_reader :env
-  end
+module PushyDaemon
 
-  def self.prepare args = {}
-    # Context parameters
-    raise "config: missing root" unless (@root = args[:root])
-    raise "config: missing env"  unless (@env = args[:env])
-
-    # Gemspec parameter
-    gemspec_path = "#{args[:root]}/#{args[:gemspec]}.gemspec"
-    raise "config: missing gemspec" unless args[:gemspec]
-    raise "config: missing gemspec file at #{gemspec_path}" unless File.exist?(gemspec_path)
-
-    # Load Gemspec
-    @spec     = Gem::Specification::load gemspec_path
-    @name     = @spec.name
-    @version  = @spec.version
-    raise "config: missing name" unless @name
-
-    # Init Chamber (defaults, etc, cmdline)
-    @files = ["#{args[:root]}/defaults.yml"]
-    @files << File.expand_path("/etc/#{@name}.yml")
-    @files << args[:config].to_s if args[:config]
-
-    # Load configuration files
-    load files: @files, namespaces: { environment: @env }
-  end
+  class ConfigMissingParameter    < StandardError; end
+  class ConfigParseError          < StandardError; end
 
-  def self.dump
-    self.to_hash.to_yaml
-  end
+  class Config
+    extend Chamber
+
+    class << self
+      attr_reader :name
+      attr_reader :spec
+      attr_reader :files
+      attr_reader :version
+      attr_reader :env
+    end
+
+    def self.prepare args = {}
+      # Context parameters
+      raise PushyDaemon::ConfigMissingParameter, "missing root" unless (@root = args[:root])
+      raise PushyDaemon::ConfigMissingParameter, "missing env"  unless (@env = args[:env])
+
+      # Gemspec parameter
+      gemspec_path = "#{args[:root]}/#{args[:gemspec]}.gemspec"
+      raise PushyDaemon::ConfigMissingParameter, "missing gemspec" unless args[:gemspec]
+      raise PushyDaemon::ConfigMissingParameter, "gemspec file not found: #{gemspec_path}" unless File.exist?(gemspec_path)
+
+      # Load Gemspec
+      @spec     = Gem::Specification::load gemspec_path
+      @name     = @spec.name
+      @version  = @spec.version
+      raise PushyDaemon::ConfigMissingParameter, "missing name" unless @name
+
+      # Init Chamber (defaults, etc, cmdline)
+      @files = ["#{args[:root]}/defaults.yml"]
+      @files << File.expand_path("/etc/#{@name}.yml")
+      @files << args[:config].to_s if args[:config]
 
+      # Load configuration files
+      load files: @files, namespaces: { environment: @env }
+
+      # Try to access any key to force parsing of the files
+      self[:dummy]
+
+    rescue Psych::SyntaxError => e
+      raise PushyDaemon::ConfigParseError, e.message
+
+    rescue Exception => e
+      raise PushyDaemon::ConfigParseError, e.message
+
+    end
+
+    def self.dump
+      self.to_hash.to_yaml
+    end
+
+  end
 end

data/lib/pushyd/constants.rb

@@ -0,0 +1,13 @@
+# Constants: global
+WAY_OUT   = "SENT"
+WAY_IN    = "RECD"
+WAY_POST  = "POST"
+
+
+# Constants: proxy
+PROXY_MESSAGE_MAX   = 1
+PROXY_USE_ACK       = false
+PROXY_SCOPE         = "dev"
+
+
+# Constants: shouter

data/lib/pushyd/daemon.rb

@@ -5,16 +5,14 @@ module PushyDaemon
       # Create a new proxy
       p = Proxy.new(logger)
 
-      # Prepare subscriptions
-      p.prepare
-
-      # Make it listen
-
       # Dump config table
       puts p.table.to_s
 
+      # Create a new shouter
+      s = Shouter.new(logger)
+
       # Start infinite loop
-      p.main
+      s.shout
     end
 
   end

data/lib/pushyd/endpoint.rb

@@ -0,0 +1,126 @@
+require 'bunny'
+require 'securerandom'
+
+module PushyDaemon
+
+  class EndpointConnexionContext    < StandardError; end
+  class EndpointConnectionError     < StandardError; end
+  class EndpointSubscribeContext    < StandardError; end
+  class EndpointSubscribeError      < StandardError; end
+
+  class Endpoint
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+  protected
+
+    def abort message
+      @logger.error "ABORT #{self.class}: #{message}"
+      raise "ABORT #{self.class}: #{message}"
+    end
+
+    def info message
+      @logger.info "#{self.class}: #{message}"
+    end
+
+    def message params = {}
+      # Indenting
+      indent = " " * (params[:way].length)
+
+      # Header
+      @logger.info sprintf(
+        "%3s %-15s %s",
+        params[:way],
+        params[:exchange],
+        params[:key]
+        )
+
+      # Attributes
+      if (params[:attrs].is_a? Hash)
+        params[:attrs].each do |name, value|
+          @logger.info sprintf("%s %-15s %s", indent, name, value)
+        end
+      end
+
+      # Body (split in lines to log them separately)
+      unless (params[:body].nil? || params[:body].empty?)
+        JSON.pretty_generate(params[:body]).each_line do |line|
+          @logger.info sprintf("%s %s", indent, line.rstrip)
+        end
+      end
+    end
+
+    # Start connexion to RabbitMQ
+    def connect busconf
+      raise PushyDaemon::EndpointConnexionContext, "invalid bus host/port" unless (busconf.is_a? Hash) &&
+        busconf[:host] && busconf[:port]
+
+      puts "connecting to #{busconf[:host]} port #{busconf[:port]}"
+      conn = Bunny.new host: (busconf[:host].to_s || "localhost").to_s,
+        port: busconf[:port].to_i,
+        user: busconf[:user].to_s,
+        pass: busconf[:pass].to_s,
+        heartbeat: :server
+      conn.start
+    rescue Bunny::TCPConnectionFailedForAllHosts, Bunny::AuthenticationFailureError, AMQ::Protocol::EmptyResponseError  => e
+      raise PushyDaemon::EndpointConnectionError, "error connecting (#{e.class})"
+    rescue Exception => e
+      raise PushyDaemon::EndpointConnectionError, "unknow (#{e.inspect})"
+    else
+      return conn
+    end
+
+    # Declare or return the exchange for this topic
+    def channel_exchange topic
+      @exchanges ||= {}
+      @exchanges[topic] ||= @channel.topic(topic, durable: true, persistent: true)
+    end
+
+    # Subscribe to interesting topic/routes and bind a listenner
+    def channel_subscribe rule
+      # Check information
+      rule_name = rule[:name].to_s
+      rule_topic = rule[:topic].to_s
+      rule_routes = rule[:routes].to_s.split(' ')
+      rule_queue = "#{Config.name}-#{PROXY_SCOPE}-#{rule[:name]}"
+      raise PushyDaemon::EndpointSubscribeContext, "rule [#{rule_name}] lacking topic" unless rule_topic
+      raise PushyDaemon::EndpointSubscribeContext, "rule [#{rule_name}] lacking routes" if rule_routes.empty?
+
+      # Create queue for this rule (remove it beforehand)
+      #conn.create_channel.queue_delete(rule_queue_name)
+      queue = @channel.queue(rule_queue, auto_delete: false, durable: true)
+
+      # Bind each route from this topic-exchange
+      topic_exchange = channel_exchange(rule_topic)
+      rule_routes.each do |route|
+        # Bind exchange to queue
+        queue.bind topic_exchange, routing_key: route
+        info "subscribe: bind [#{rule_topic}/#{route}] \t> #{rule_queue}"
+
+        # Add row to config table
+        @table.add_row [rule_name, rule_topic, route, rule[:relay].to_s, rule[:title].to_s ]
+      end
+
+      # Subscribe to our new queue
+      queue.subscribe(block: false, manual_ack: PROXY_USE_ACK, message_max: PROXY_MESSAGE_MAX) do |delivery_info, metadata, payload|
+
+        # Handle the message
+        handle_message rule, delivery_info, metadata, payload
+
+      end
+
+    rescue Bunny::PreconditionFailed => e
+      raise PushyDaemon::EndpointSubscribeError, "PreconditionFailed: [#{rule_topic}] code(#{e.channel_close.reply_code}) message(#{e.channel_close.reply_text})"
+
+    rescue Exception => e
+      raise PushyDaemon::EndpointSubscribeError, "unhandled (#{e.inspect})"
+
+    end
+
+    def handle_message rule, delivery_info, metadata, payload
+    end
+
+  end
+end

data/lib/pushyd/proxy.rb

@@ -1,25 +1,18 @@
 require 'rest_client'
-require 'bunny'
 require 'yaml'
 require 'json'
 require 'terminal-table'
 
-# Constants
-PROXY_MESSAGE_MAX   = 1
-PROXY_USE_ACK       = false
-PROXY_SCOPE         = "dev"
-# PROXY_IDENT = "proxy"
-# QUEUE_HOST = `hostname`.to_s.chomp
-# SEPARATOR  = "="*160
-# ACK_PERCENT = 50
+module PushyDaemon
 
+  # class ProxyConnexionContext    < StandardError; end
 
-module PushyDaemon
-  class Proxy
+  class Proxy < Endpoint
 
     attr_accessor :table
 
     def initialize(logger)
+      # Init
       @exchanges = {}
       @logger = logger
 
@@ -28,123 +21,41 @@ module PushyDaemon
       @table.title = "Propagation rules"
       @table.headings = ["queue binding", "topic", "route", "relay", "title"]
       @table.align_column(5, :right)
-    end
 
-    def prepare
       # Start connexion to RabbitMQ and create channel
       conn = connect Config.bus
       @channel = conn.create_channel
-      info "prepare: connected on a channel"
+      info "connected on a channel"
 
-      # Check rules
-      unless (Config.rules.is_a? Enumerable) && !Config.rules.empty?
+      # Check config
+      config_rules = Config[:rules]
+      unless (config_rules.is_a? Enumerable) && !config_rules.empty?
         abort "prepare: empty [rules] section"
       end
-      info "prepare: found [#{Config.rules.size}] rules"
+      info "found rules: #{config_rules.keys.join(', ')}"
 
       # Subsribe for each and every rule/route
-      Config.rules.each do |name, rule|
+      config_rules.each do |name, rule|
         rule[:name] = name
         channel_subscribe rule
         #abort "prepare: OK"
       end
 
       # Send config table to logs
-      info "prepare: dumping configuration\n#{@table.to_s}"
-    end
+      info "dumping configuration\n#{@table.to_s}"
 
-    def main
-      loop do
-        info "ping"
-        sleep(1)
-      end
+    rescue Bunny::TCPConnectionFailedForAllHosts => e
+      abort "ERROR: cannot connect to RabbitMQ hosts (#{e.inspect})"
     end
 
   private
 
-    def abort message
-      @logger.error "ABORT: #{message}"
-      raise "ABORT: #{message}"
-    end
-
-    def info message
-      @logger.info message
-    end
-
-    def dump_rules rules
-
-    end
-
-    # Start connexion to RabbitMQ
-    def connect busconf
-      abort "connect: bus host/port not found" unless busconf.is_a? Hash
-
-      puts "connecting to #{busconf[:host]} port #{busconf[:port]}"
-      conn = Bunny.new host: (busconf[:host].to_s || "localhost").to_s,
-        port: busconf[:port].to_i,
-        user: busconf[:user].to_s,
-        pass: busconf[:pass].to_s,
-        heartbeat: :server
-      conn.start
-    rescue Bunny::TCPConnectionFailedForAllHosts, Bunny::AuthenticationFailureError, AMQ::Protocol::EmptyResponseError  => e
-      abort "connect: error connecting to RabbitMQ (#{e.class})"
-    rescue Exception => e
-      abort "connect: unknow connection error (#{e.inspect})"
-    else
-      return conn
-    end
-
-    # Declare or return the exchange for this topic
-    def channel_exchange topic
-      @exchanges ||= {}
-      @exchanges[topic] ||= @channel.topic(topic, durable: true, persistent: true)
-    end
-
-    # Subscribe to interesting topic/routes and bind a listenner
-    def channel_subscribe rule
-      # Check information
-      rule_name = rule[:name].to_s
-      rule_topic = rule[:topic].to_s
-      rule_routes = rule[:routes].to_s.split(' ')
-      rule_queue = "#{Config.name}-#{PROXY_SCOPE}-#{rule[:name]}"
-      abort "subscribe: rule [#{rule_name}] lacking topic" unless rule_topic
-      abort "subscribe: rule [#{rule_name}] lacking routes" if rule_routes.empty?
-
-      # Create queue for this rule (remove it beforehand)
-      #conn.create_channel.queue_delete(rule_queue_name)
-      queue = @channel.queue(rule_queue, auto_delete: false, durable: true)
-
-      # Bind each route from this topic-exchange
-      topic_exchange = channel_exchange(rule_topic)
-      rule_routes.each do |route|
-        # Bind exchange to queue
-        queue.bind topic_exchange, routing_key: route
-        info "subscribe: bind: \t[#{rule_topic}] \t[#{route}] \t> [#{rule_queue}]"
-
-        # Add row to config table
-        @table.add_row [rule_name, rule_topic, route, rule[:relay].to_s, rule[:title].to_s ]
-      end
-
-      # Subscribe to our new queue
-      queue.subscribe(block: false, manual_ack: PROXY_USE_ACK, message_max: PROXY_MESSAGE_MAX) do |delivery_info, metadata, payload|
-
-        # Handle the message
-        handle_message rule[:name], rule, delivery_info, metadata, payload
-
-      end
-
-    rescue Bunny::PreconditionFailed => e
-      abort "subscribe: PreconditionFailed: [#{rule_topic}] code(#{e.channel_close.reply_code}) message(#{e.channel_close.reply_text})"
-    rescue Exception => e
-      abort "subscribe: unhandled (#{e.inspect})"
-
-    end
-
     # Handle the reception of a message on a queue
     def handle_message rule, delivery_info, metadata, payload
       # Prepare data
       rule_name = rule[:name]
-      msg_topic = delivery_info.exchange
+      rule_relay = rule[:relay]
+      msg_exchange = delivery_info.exchange
       msg_rkey = delivery_info.routing_key.force_encoding('UTF-8')
       msg_headers = metadata.headers || {}
 
@@ -152,38 +63,43 @@ module PushyDaemon
       data = parse payload, metadata.content_type  #, rule
 
       # Announce match
-      header rule_name, "<", msg_topic, msg_rkey
+      message way: WAY_IN,
+        exchange: msg_exchange,
+        key: msg_rkey,
+        body: data,
+        attrs: {
+          'rule' => rule_name,
+          'app-id' => metadata.app_id,
+          'content-type' => metadata.content_type,
+        }
 
       # Build notification payload
-      body = {
-        # received: msg_topic,
-        exchange: msg_topic,
+      post_body = {
+        exchange: msg_exchange,
         route: msg_rkey,
-        #headers: msg_headers,
         sent_at: msg_headers['sent_at'],
         sent_by: msg_headers['sent_by'],
         data: data,
         }
-      pretty_body = JSON.pretty_generate(body)
-
-      # Dump body data
-      puts "RULE: #{rule.inspect}"
-      puts "APP-ID: #{metadata.app_id}"
-      puts "CONTENT-TYPE: #{metadata.content_type}"
-      puts pretty_body
 
       # Propagate data if needed
-      #propagate rule[:relay], pretty_body
+      propagate rule_relay, post_body if rule_relay
     end
 
-    def propagate url, body
+    def propagate relay_url, post_body
       # Nothing more to do if no relay
-      return if url.nil? || url.empty?
+      return if relay_url.nil? || relay_url.empty?
+      id = SecureRandom.random_number(100)
+
+      # Log message details
+      message way: WAY_POST,
+        exchange: id,
+        key: relay_url,
+        body: post_body
 
       # Push message to URL
-      puts "> POST #{url}"
-      response = RestClient.post url.to_s, body, :content_type => :json
-      puts "< #{response.body}"
+      response = RestClient.post relay_url.to_s, JSON.pretty_generate(post_body), :content_type => :json
+      info "#{id}: #{response.body}"
 
       rescue Exception => e
         abort "propagate: #{e.message}"
@@ -220,49 +136,3 @@ module PushyDaemon
 
 end
 
-
-# def prepare_shout
-
-
-# # Prepare shout config
-# shout_config = config[:shout]
-# shout_exchange = nil
-# shout_keys = []
-
-# if shout_config.is_a? Hash
-#   shout_exchange = topic(channel, shout_config[:topic])
-#   shout_keys = shout_config[:keys] if shout_config[:keys].is_a? Array
-# end
-
-# end
-
-# def endlessly
-#   # Endless loop with shout config
-#   begin
-#     loop do
-#       if shout_exchange
-#         random_string = SecureRandom.hex
-#         random_key = shout_keys.sample || "random"
-#         shout shout_exchange, [:ping, random_key, random_string], {}
-#       end
-#       sleep 1
-#     end
-#   rescue AMQ::Protocol::EmptyResponseError => e
-#     abort "ERROR: AMQ::Protocol::EmptyResponseError (#{e.inspect})"
-#   rescue Bunny::TCPConnectionFailedForAllHosts => e
-#     abort "ERROR: cannot connect to RabbitMQ hosts (#{e.inspect})"
-#   rescue Bunny::ChannelAlreadyClosed => e
-#     abort "ERROR: channel unexpectedly closed (#{e.inspect})"
-#     # sleep 1
-#     # retry
-#   rescue Bunny::PreconditionFailed => e
-#     abort "ERROR: precondition failed (#{e.inspect})"
-#   rescue Interrupt => e
-#     channel.close
-#     conn.close
-#     abort "QUITTING"
-#   end
-# end
-
-# Dump configuration
-# Hashie.symbolize_keys! config

data/lib/pushyd/shouter.rb

@@ -0,0 +1,101 @@
+require 'yaml'
+require 'json'
+
+module PushyDaemon
+
+  class ShouterResponseError    < StandardError; end
+  class ShouterChannelClosed    < StandardError; end
+  class ShouterPreconditionFailed    < StandardError; end
+  class ShouterInterrupted      < StandardError; end
+  class EndpointTopicContext    < StandardError; end
+
+  class Shouter < Endpoint
+
+    attr_accessor :table
+
+    def initialize(logger)
+      # Init
+      @logger = logger
+      @keys = []
+
+      # Start connexion to RabbitMQ and create channel
+      conn = connect Config.bus
+      @channel = conn.create_channel
+      info "connected on a channel"
+
+      # Check config
+      config_shout = Config[:shout]
+      if (config_shout.is_a? Enumerable) && !config_shout.empty?
+        @keys = config_shout[:keys] if config_shout[:keys].is_a? Array
+        @topic = config_shout[:topic]
+
+        info "found topic: #{@topic}"
+        info "found keys: #{@keys.join(', ')}"
+      else
+        abort "prepare: empty [shout] section"
+      end
+
+      # Create exchange
+      raise PushyDaemon::EndpointTopicContext unless @topic
+      @exchange = @channel.topic(@topic, durable: true, persistent: true)
+
+      # if shout_config.is_a? Hash
+      #   shout_keys = shout_config[:keys] if config_shout[:keys].is_a? Array
+      # end
+
+    rescue Bunny::TCPConnectionFailedForAllHosts => e
+      abort "ERROR: cannot connect to RabbitMQ hosts (#{e.inspect})"
+    end
+
+    def shout
+      # Prepare exchange
+      loop do
+        if true # shout_exchange
+          random_string = SecureRandom.hex
+          random_key = @keys.sample || "random"
+          channel_shout [:ping, random_key, random_string], {}
+        end
+        sleep 1
+      end
+    rescue AMQ::Protocol::EmptyResponseError => e
+      raise PushyDaemon::ShouterResponseError, "#{e.class} (#{e.inspect})"
+    rescue Bunny::ChannelAlreadyClosed => e
+      raise PushyDaemon::ShouterChannelClosed, "#{e.class} (#{e.inspect})"
+    rescue Bunny::PreconditionFailed => e
+      raise PushyDaemon::ShouterPreconditionFailed, "#{e.class} (#{e.inspect})"
+
+    rescue Interrupt => e
+      @channel.close
+      # conn.close
+      raise PushyDaemon::ShouterInterrupted, "#{e.class} (#{e.inspect})"
+    end
+
+  private
+
+    def channel_shout keys, body = {}
+      # Add timestamp
+      headers = {
+        sent_at: DateTime.now.iso8601,
+        sent_by: Config.name
+        }
+      exchange_name = @exchange.name
+
+      # Prepare key and data
+      routing_key = keys.unshift(exchange_name).join('.')
+
+      # Announce shout
+      message way: WAY_OUT, exchange: exchange_name, key: routing_key, body: nil, attrs: {}
+
+      # Publish
+      @exchange.publish(body.to_json,
+        routing_key: routing_key,
+        headers: headers,
+        app_id: Config.name,
+        content_type: "application/json",
+        )
+
+    end
+
+  end
+end
+

data/lib/pushyd.rb

@@ -1,4 +1,3 @@
-
 # Global libs
 require "rubygems"
 require "json"
@@ -6,8 +5,11 @@ require "thread"
 require "singleton"
 # require "newrelic_rpm"
 
-# Project's libs
+# Project libs
 require_relative "pushyd/config"
+require_relative "pushyd/constants"
+require_relative "pushyd/endpoint"
 require_relative "pushyd/proxy"
+require_relative "pushyd/shouter"
 require_relative "pushyd/daemon"
 

data/pushyd.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   # Project version
-  spec.version                      = "0.0.2"
+  spec.version                      = "0.1.1"
 
   # Project description
   spec.name                         = "pushyd"
@@ -14,10 +14,10 @@ Gem::Specification.new do |spec|
   spec.date                         = Time.now.strftime("%Y-%m-%d")
 
   # List files and executables
-  spec.files                        = `git ls-files -z`.split("\x0").reject{ |f| f == "dashboard.png"}
+  spec.files                        = `git ls-files -z`.split("\x0")
   spec.executables                  = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths                = ["lib"]
-  spec.required_ruby_version        = ">= 2.2"
+  spec.required_ruby_version        = ">= 2.1"
 
   # Development dependencies
   spec.add_development_dependency   "bundler", "~> 1.6"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pushyd
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Bruno MEDICI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -180,8 +180,11 @@ files:
 - defaults.yml
 - lib/pushyd.rb
 - lib/pushyd/config.rb
+- lib/pushyd/constants.rb
 - lib/pushyd/daemon.rb
+- lib/pushyd/endpoint.rb
 - lib/pushyd/proxy.rb
+- lib/pushyd/shouter.rb
 - pushyd.gemspec
 homepage: http://github.com/bmedici/pushyd
 licenses:
@@ -195,7 +198,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="