suj-pusher 0.2.3 → 0.2.5

data/README.md

@@ -59,7 +59,7 @@ To start the server run:
 To stop the server run:
 
 ```
-/path/to/bin/pusher start -H localhost -P 6379 -b 0 -n pusher -p /var/run/pids
+/path/to/bin/pusher stop -H localhost -P 6379 -b 0 -n pusher -p /var/run/pids
 ```
 
 If you set a piddir (using -p option) when starting the server then you must supply the same option when stopping or restarting the server.

data/lib/suj/pusher/apn_connection.rb

@@ -1,12 +1,15 @@
 require "eventmachine"
 require "iobuffer"
-
 require "base64"
+require 'suj/pusher/monkey/vash'
+
 module Suj
   module Pusher
     class APNConnection < EM::Connection
       include Suj::Pusher::Logger
 
+      @@last_id = 0
+
       ERRORS = {
         0 => "No errors encountered",
         1 => "Processing error",
@@ -26,12 +29,16 @@ module Suj
         @disconnected = true
         @pool = pool
         @options = options
+        @processing_ids = Vash.new
         @cert_key = Digest::SHA1.hexdigest(@options[:cert])
         @cert_file = File.join(Suj::Pusher.config.certs_path, @cert_key)
         @buffer = IO::Buffer.new
+        self.comm_inactivity_timeout = 60          # Close after 60 sec of inactivity
+
         File.open(@cert_file, "w") do |f|
           f.write @options[:cert]
         end
+
         @ssl_options = {
           private_key_file: @cert_file,
           cert_chain_file: @cert_file,
@@ -39,6 +46,10 @@ module Suj
         }
       end
 
+      def options
+        @options
+      end
+
       def disconnected?
         @disconnected
       end
@@ -47,22 +58,39 @@ module Suj
         begin
           @notifications = []
           data[:apn_ids].each do |apn_id|
-            @notifications << Suj::Pusher::ApnNotification.new(data.merge({token: apn_id}))
+            if ! @pool.valid_token?(@cert_key, apn_id)
+              warn "Skipping invalid #{apn_id} APN id"
+              next
+            end
+            notification = Suj::Pusher::ApnNotification.new(data.merge({token: apn_id, id: @@last_id}))
+            @processing_ids[@@last_id.to_s] = apn_id
+            @@last_id += 1
+            @notifications << notification
           end
-          if ! disconnected?
-            info "APN delivering data"
-            send_data(@notifications.join)
-            info "APN push notification sent"
-            @notifications = nil
-            info "APN delivered data"
-          else
-            info "APN connection unavailable"
+
+          @processing_ids.cleanup!
+          info "Processing list size #{@processing_ids.size}"
+
+          if @notifications.empty?
+            warn "No valid tokens, skip message"
+            return
           end
+
+          if disconnected?
+            warn "Connection not ready yet, queue notifications for later"
+            return
+          end
+
+          info "APN delivering data"
+          send_data(@notifications.join)
+          @notifications = nil
+          info "APN delivered data"
         rescue Suj::Pusher::ApnNotification::PayloadTooLarge => e
           error "APN notification payload too large."
           debug @notifications.join.inspect
         rescue => ex
           error "APN notification error : #{ex}"
+          error ex.backtrace
         end
       end
 
@@ -85,6 +113,10 @@ module Suj
           cmd, status, id = data.unpack("CCN")
           if cmd != 8
             error "APN push response command differs from 8"
+          elsif status == 8
+            token = @processing_ids[id.to_s]
+            @pool.invalidate_token(@cert_key, token)
+            warn "APN invalid (id: #{id}) token #{token}"
           elsif status != 0
             error "APN push error received: #{ERRORS[status]} for id #{id}"
           end
@@ -94,13 +126,13 @@ module Suj
       def connection_completed
         info "APN Connection established..."
         @disconnected = false
-        if ! @notifications.nil?
-          info "EST - APN delivering data"
-          send_data(@notifications.join)
-          info "APN push notification sent"
-          @notifications = nil
-          info "EST - APN delivered data"
-        end
+
+        return if @notifications.nil? || @notifications.empty?
+
+        info "EST - APN delivering data"
+        send_data(@notifications.join)
+        @notifications = nil
+        info "EST - APN delivered data"
       end
 
       def unbind

data/lib/suj/pusher/apn_feedback_connection.rb

@@ -12,7 +12,7 @@ module Suj
         @disconnected = true
         @options = options
         @pool = pool
-        @cert_key = Digest::SHA1.hexdigest("FEEDBACK" + @options[:cert])
+        @cert_key = Digest::SHA1.hexdigest(@options[:cert])
         @cert_file = File.join(Suj::Pusher.config.certs_path, @cert_key)
         @buffer = IO::Buffer.new
         self.comm_inactivity_timeout = 10          # Close after 10 sec of inactivity
@@ -24,6 +24,7 @@ module Suj
           cert_chain_file: @cert_file,
           verify_peer: false
         }
+        info "APN feedback #{@cert_key}: Creating"
       end
 
       def disconnected?
@@ -31,7 +32,7 @@ module Suj
       end
 
       def post_init
-        info "APN Feedback Connection init "
+        info "APN feedback #{@cert_key}: Connection init "
         start_tls(@ssl_options)
       end
 
@@ -48,19 +49,20 @@ module Suj
         while @buffer.size >= 38
           timestamp, size = @buffer.read(6).unpack("Nn")
           token = @buffer.read(size)
-          puts " FEEDBACK TIMESTAMP: #{timestamp}  SIZE: #{size} TOKEN: #{token}"
+          info "APN feedback #{@cert_key}: TIMESTAMP: #{timestamp} SIZE: #{size} TOKEN: #{token}"
+          @pool.invalidate_token(@cert_key, token)
         end
       end
 
       def connection_completed
-        info "APN Feedback Connection established..."
+        info "APN feedback #{@cert_key}: Connection established..."
         @disconnected = false
       end
 
       def unbind
-        info "APN Feedback Connection closed..."
+        info "APN feedback #{@cert_key}: Connection closed..."
         @disconnected = true
-        @pool.remove_connection(@cert_key)
+        @pool.remove_feedback_connection(@cert_key)
       end
     end
   end

data/lib/suj/pusher/apn_notification.rb

@@ -9,6 +9,7 @@ module Suj
 
       def initialize(options = {})
         @token = options[:token]
+        @id  = options[:id]
         @ttl = options[:time_to_live] || 0
         @options = options
         raise InvalidToken if @token.nil? || (@token.length != 64)
@@ -38,17 +39,10 @@ module Suj
       end
 
       def encode_data
-        # identifier = 0
-        # expiry = get_expiry
-        # size = [payload].pack("a*").size
-        # data_array = [1, identifier, expiry, 32, @token, size, payload]
-        # info("PAYLOAD: #{data_array}")
-        # data_array.pack("cNNnH*na*")
-        
         items = [
           [1, 32,               @token ],                           # token
           [2, payload.bytesize, payload ],                          # payload
-          [3, 4,                OpenSSL::Random::random_bytes(4) ], # random identifier
+          [3, 4,                @id],                               # id identifier
           [4, 4,                get_expiry ],                       # expiration date
           [5, 1,                10 ]                                # high priority
         ]
@@ -58,7 +52,7 @@ module Suj
         frame_data = 
           items[0].pack("CnH*") +
           items[1].pack("CnA*") +
-          items[2].pack("CnA*") +
+          items[2].pack("CnN") +
           items[3].pack("CnN")  +
           items[4].pack("CnC")
 

data/lib/suj/pusher/connection_pool.rb

@@ -12,15 +12,105 @@ module Suj
       APN_GATEWAY = "gateway.push.apple.com"
       FEEDBACK_SANDBOX = "feedback.sandbox.push.apple.com"
       FEEDBACK_GATEWAY = "feedback.push.apple.com"
+      CONNECTION_EXPIRY = 60*60*24*30  # Approx 1 month
+      TOKEN_EXPIRY      = 60*60*24*7   # Approx 1 week
       APN_PORT = 2195
       FEEDBACK_PORT = 2196
 
+      class UnknownConnection < StandardError; end
+
       def initialize(daemon)
         @pool = {}
+        @feedback_pool = {}
         @daemon = daemon
         @mutex = Mutex.new
+        @feedback_mutex = Mutex.new
+        @invalid_tokens = Vash.new
+      end
+
+      def get_connection(options = {})
+        if options.has_key?(:cert)
+          if options.has_key?(:development) && options[:development]
+            return apn_sandbox_connection(options)
+          else
+            return apn_connection(options)
+          end
+        elsif options.has_key?(:api_key)
+          return gcm_connection(options)
+        elsif options.has_key?(:secret) && options.has_key?(:sid)
+          return wns_connection(options)
+        elsif  options.has_key?(:wpnotificationclass)
+          return wpns_connection(options)
+        end
+        raise UnknownConnection
+      end
+
+      def get_feedback_connection(options = {})
+        if options.has_key?(:cert)
+          if options.has_key?(:development) && options[:development]
+            return feedback_sandbox_connection(options)
+          else
+            return feedback_connection(options)
+          end
+        end
+        return nil
+      end
+
+      def remove_feedback_connection(key)
+        @feedback_mutex.synchronize {
+          info "Removing feedback connection #{key}"
+          @feedback_pool.delete(key)
+        }
+      end
+
+      def remove_connection(key)
+        @mutex.synchronize {
+          info "Removing connection #{key}"
+          info "Connection not found" unless @pool.delete(key)
+        }
+      end
+
+      def invalidate_token(conn, token)
+        @invalid_tokens[conn, CONNECTION_EXPIRY] = Vash.new if @invalid_tokens[conn].nil?
+        @invalid_tokens[conn][token, TOKEN_EXPIRY] = Time.now.to_s
+      end
+
+      def valid_token?(conn, token)
+        return true if ! @invalid_tokens[conn]
+        return false if @invalid_tokens[conn].has_key?(token)
+        return true
+      end
+
+      # Method that creates APN feedback connections
+      def feedback
+        @invalid_tokens.cleanup!
+        @invalid_tokens.each { |k,v| v.cleanup! if v }
+
+        @pool.each do |k, conn|
+          next if ! conn.is_a?(Suj::Pusher::APNConnection)
+          conn = get_feedback_connection(conn.options)
+        end
       end
 
+      def close
+        @mutex.synchronize {
+          @pool.each do |k, conn|
+            conn.close_connection_after_writing
+          end
+        }
+        @feedback_mutex.synchronize {
+          @feedback_pool.each do |k, conn|
+            conn.close_connection
+          end
+        }
+      end
+
+      def pending_connections?
+        @pool.size + @feedback_pool.size > 0
+      end
+
+      private
+
       def apn_connection(options = {})
         cert = Digest::SHA1.hexdigest options[:cert]
         info "APN connection #{cert}"
@@ -31,26 +121,25 @@ module Suj
 
       def apn_sandbox_connection(options = {})
         cert = Digest::SHA1.hexdigest options[:cert]
-        info "APN connection #{cert}"
+        info "APN sandbox connection #{cert}"
         @mutex.synchronize do
           @pool[cert] ||= EM.connect(APN_SANDBOX, APN_PORT, APNConnection, self, options)
         end
       end
 
       def feedback_connection(options = {})
-        cert = Digest::SHA1.hexdigest("FEEDBACK" + options[:cert])
-        info "APN Feedback connection #{cert}"
-        @mutex.synchronize do
-          @pool[cert] ||= EM.connect(FEEDBACK_GATEWAY, FEEDBACK_PORT, APNFeedbackConnection, self, options)
+        cert = Digest::SHA1.hexdigest(options[:cert])
+        info "Get APN feedback connection #{cert}"
+        @feedback_mutex.synchronize do
+          @feedback_pool[cert] ||= EM.connect(FEEDBACK_GATEWAY, FEEDBACK_PORT, APNFeedbackConnection, self, options)
         end
       end
 
       def feedback_sandbox_connection(options = {})
-        info "Feedback connection"
-        cert = Digest::SHA1.hexdigest("FEEDBACK" + options[:cert])
-        info "APN Sandbox Feedback connection #{cert}"
-        @mutex.synchronize do
-          @pool[cert] ||= EM.connect(FEEDBACK_SANDBOX, FEEDBACK_PORT, APNFeedbackConnection, self, options)
+        cert = Digest::SHA1.hexdigest(options[:cert])
+        info "Get APN sandbox feedback connection #{cert}"
+        @feedback_mutex.synchronize do
+          @feedback_pool[cert] ||= EM.connect(FEEDBACK_SANDBOX, FEEDBACK_PORT, APNFeedbackConnection, self, options)
         end
       end
 
@@ -63,14 +152,6 @@ module Suj
         end
       end
 
-      def apn_connection(options = {})
-        cert = Digest::SHA1.hexdigest options[:cert]
-        info "APN connection #{cert}"
-        @mutex.synchronize do
-          @pool[cert] ||= EM.connect(APN_GATEWAY, APN_PORT, APNConnection, self, options)
-        end
-      end
-
       def wns_connection(options = {})
         cert = Digest::SHA1.hexdigest options[:secret]
         info "WNS connection #{cert}"
@@ -89,11 +170,6 @@ module Suj
         end
       end
 
-      def remove_connection(key)
-        info "Removing connection #{key}"
-        info "Connection not found" unless @pool.delete(key)
-      end
-
     end
 
   end

data/lib/suj/pusher/daemon.rb

@@ -5,6 +5,7 @@ require 'openssl'
 require 'em-hiredis'
 require "multi_json"
 require 'fileutils'
+require 'fiber'
 
 module Suj
   module Pusher
@@ -16,125 +17,92 @@ module Suj
       def start
         info "Starting pusher daemon"
         info " subsribe to push messages from #{redis_url} namespace #{redis_namespace}"
-        @last_feedback = Time.now
-        @last_sandbox_feedback = Time.now
         EM.run do
-          wait_msg
-        end
-      end
 
-      def stop
-        info "Stopping daemon process"
-        begin
-          EM.stop
-        rescue
-        end
-        info "Stopped daemon process"
-      end
-
-      private
-
-      def wait_msg
-        defer = redis.brpop "#{redis_namespace}:#{MSG_QUEUE}", 0
-        defer.callback do |_, msg|
-          begin
-            info "RECEIVED MESSAGE"
-            data = Hash.symbolize_keys(MultiJson.load(msg))
-            send_notification(data)
-            info "SENT MESSAGE"
-            retrieve_feedback(data)
-          rescue MultiJson::LoadError
-            warn("Received invalid json data, discarding msg")
-          rescue => e
-            error("Error sending notification : #{e}")
-            error e.backtrace
+          EM.add_periodic_timer(FEEDBACK_TIME) do
+            info "Starting APN feedback service"
+            pool.feedback
           end
-          EM.next_tick { wait_msg }
-        end
-        defer.errback do |e|
-          error e
-          EM.next_tick { wait_msg }
-        end
-      end
 
-      def send_notification(msg)
-        if msg.has_key?(:cert)
-          if msg.has_key?(:development) && msg[:development]
-            send_apn_sandbox_notification(msg)
-          else
-            send_apn_notification(msg)
-          end
-        elsif msg.has_key?(:api_key)
-          send_gcm_notification(msg)
-        elsif msg.has_key?(:secret) && msg.has_key?(:sid)
-          #wns push notification
-          send_wns_notification(msg)
-        elsif  msg.has_key?(:wpnotificationclass)
-          #send wpns push notification
-          send_wpns_notification(msg)
-        else
-          warn "Could not determine push notification service."
+          Fiber.new {
+            loop
+          }.resume
         end
       end
 
-      def retrieve_feedback(msg)
-        if msg.has_key?(:cert)
-          if msg.has_key?(:development) && msg[:development]
-            feedback_sandbox_connection(msg)
-          else
-            feedback_connection(msg)
-          end
+      def stop
+        pool.close
+        redis.close
+
+        if ! pool.pending_connections?
+          EM.stop
+          info "Stopped daemon process"
+        else
+          info "Waiting for pending connections"
+          EM.add_periodic_timer(5) {
+            if ! pool.pending_connections?
+              EM.stop
+              info "Stopped daemon process"
+            end
+          }
         end
       end
 
-      def send_apn_notification(msg)
-        info "Sending APN notification via connection #{Digest::SHA1.hexdigest(msg[:cert])}"
-        conn = pool.apn_connection(msg)
-        conn.deliver(msg)
-        # msg[:apn_ids].each do |apn_id|
-        #   conn.deliver(msg.merge({token: apn_id}))
-        # end
-      end
+      private
 
-      def send_apn_sandbox_notification(msg)
-        info "Sending APN sandbox notification via connection #{Digest::SHA1.hexdigest(msg[:cert])}"
-        conn = pool.apn_sandbox_connection(msg)
+      def loop
+        msg = get_msg
+        return next_tick { loop } if msg.nil?
+        conn = get_connection(msg)
+        return next_tick { loop } if conn.nil?
         conn.deliver(msg)
-        # msg[:apn_ids].each do |apn_id|
-        #   conn.deliver(msg.merge({token: apn_id}))
-        # end
-      end
-
-      def feedback_connection(msg)
-        return Time.now - @last_feedback < FEEDBACK_TIME
-        info "Get feedback information"
-        conn = pool.feedback_connection(msg)
-        @last_feedback = Time.now
+        next_tick { loop }
       end
 
-      def feedback_sandbox_connection(msg)
-        return if Time.now - @last_sandbox_feedback < FEEDBACK_TIME
-        info "Get feedback sandbox information"
-        conn = pool.feedback_sandbox_connection(msg)
-        @last_sandbox_feedback = Time.now
+      def next_tick(&blk)
+        EM.next_tick { Fiber.new { blk.call }.resume }
       end
 
-      def send_gcm_notification(msg)
-        info "Sending GCM notification via connection #{msg[:api_key]}"
-        conn = pool.gcm_connection(msg)
-        conn.deliver(msg)
+      def msg_queue
+        @msg_queue ||= "#{redis_namespace}:#{MSG_QUEUE}"
       end
 
-      def send_wns_notification(msg)
-        info "Sending WNS notification via connection #{Digest::SHA1.hexdigest(msg[:secret])}"
-        conn = pool.wns_connection(msg)
-        conn.deliver(msg)
+      def get_msg
+        f = Fiber.current
+        begin
+          defer = redis.brpop msg_queue, 0
+          defer.callback do |_, msg|
+            info "Received message"
+            begin
+              data = Hash.symbolize_keys(MultiJson.load(msg))
+              f.resume(data)
+            rescue MultiJson::LoadError
+              warn("Message has bad json format, discarding")
+              f.resume(nil)
+            rescue => e
+              error(e)
+              f.resume(nil)
+            end
+          end
+          defer.errback do |e|
+            f.resume(nil)
+          end
+        rescue EventMachine::Hiredis::Error => e
+          info e
+        rescue => ex
+          error ex
+        end
+        return Fiber.yield
       end
 
-      def send_wpns_notification(msg)
-        info "Sending WPNS notification via connection #{Digest::SHA1.hexdigest(msg[:secret])}"
-        conn = pool.wpns_connection(msg)
-        conn.deliver(msg)
+      def get_connection(options)
+        info "Get connection"
+        begin
+          return pool.get_connection(options)
+        rescue ConnectionPool::UnknownConnection
+          error "Could not find connection"
+          return nil
+        end
       end
 
       def redis_url

data/lib/suj/pusher/monkey/vash.rb

@@ -0,0 +1,110 @@
+  #############################################################################
+  # Class: Vash (Ruby Volatile Hash)
+  # Hash that returns values only for a short time.  This is useful as a cache
+  # where I/O is involved.  The primary goal of this object is to reduce I/O 
+  # access and due to the nature of I/O being slower then memory, you should also
+  # see a gain in quicker response times.
+  #
+  # For example, if Person.first found the first person from the database & cache 
+  # was an instance of Vash then the following would only contact the database for
+  # the first iteration:
+  #
+  # > cache = Vash.new
+  # > 1000.times {cache[:person] ||= Person.first}
+  # 
+  # However if you did the following immediately following that command it would 
+  # hit the database again:
+  #
+  # > sleep 61
+  # > cache[:person] ||= Person.first
+  #
+  # The reason is that there is a default Time-To-Live of 60 seconds.  You can 
+  # also set a custom TTL of 10 seconds like so:
+  # 
+  # > cache[:person, 10] = Person.first
+  # 
+  # The Vash object will forget any answer that is requested after the specified
+  # TTL.  It is a good idea to manually clean things up from time to time because 
+  # it is possible that you'll cache data but never again access it and therefor 
+  # it will stay in memory after the TTL has expired.  To clean up the Vash object, 
+  # call the method: cleanup!
+  # 
+  # > sleep 11        # At this point the prior person ttl will be expired
+  #                   #  but the person key and value will still exist.
+  # > cache           # This will still show the the entire set of keys 
+  #                   #  regardless of the TTL, the :person will still exist
+  # > cache.cleanup!  # All of the TTL's will be inspected and the expired 
+  #                   #  :person key will be deleted.
+  #
+  # The cleanup must be manually called because the purpose of the Vash is to 
+  # lessen needless I/O calls and gain speed not to slow it down with regular
+  # maintenance.
+  class Vash < Hash
+    def initialize(constructor = {})
+      @register ||= {} # remembers expiration time of every key
+      if constructor.is_a?(Hash)
+        super()
+        merge(constructor)
+      else
+        super(constructor)
+      end
+    end
+    
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_reader, :[] unless method_defined?(:regular_reader)
+    
+    def [](key)
+      sterilize(key)
+      clear(key) if expired?(key)
+      regular_reader(key)
+    end
+    
+    def []=(key, *args)
+      # a little bit o variable hacking to support (h[key, ttl] = value), which will come 
+      # accross as (key, [ttl, value]) whereas (h[key]=value) comes accross as (key, [value])
+      if args.length == 2
+        value, ttl = args[1], args[0]
+      elsif args.length == 1
+        value, ttl = args[0], 60
+      else
+        raise ArgumentError, "Wrong number of arguments, expected 2 or 3, received: #{args.length+1}\n"+
+                             "Example Usage:  volatile_hash[:key]=value OR volatile_hash[:key, ttl]=value"
+      end
+      sterilize(key)
+      ttl(key, ttl)
+      regular_writer(key, value)
+    end
+    
+    def merge(hsh)
+      hsh.map {|key,value| self[sterile(key)] = hsh[key]}
+      self
+    end
+    
+    def cleanup!
+      now = Time.now.to_i
+      @register.map {|k,v| clear(k) if v < now}
+    end
+    
+    def clear(key)
+      sterilize(key)
+      @register.delete key
+      self.delete key
+    end
+    
+  private
+    def expired?(key)
+      Time.now.to_i > @register[key].to_i
+    end
+    
+    def ttl(key, secs=60)
+      @register[key] = Time.now.to_i + secs.to_i
+    end
+    
+    def sterile(key)
+      String === key ? key.chomp('!').chomp('=') : key.to_s.chomp('!').chomp('=').to_sym
+    end
+    
+    def sterilize(key)
+      key = sterile(key)
+    end
+  end

data/lib/suj/pusher/version.rb

@@ -1,5 +1,5 @@
 module Suj
   module Pusher
-    VERSION = '0.2.3'
+    VERSION = '0.2.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: suj-pusher
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-09 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &10281040 !ruby/object:Gem::Requirement
+  requirement: &10452580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10281040
+  version_requirements: *10452580
 - !ruby/object:Gem::Dependency
   name: em-hiredis
-  requirement: &10280620 !ruby/object:Gem::Requirement
+  requirement: &10451520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10280620
+  version_requirements: *10451520
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &10280020 !ruby/object:Gem::Requirement
+  requirement: &10451080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10280020
+  version_requirements: *10451080
 - !ruby/object:Gem::Dependency
   name: daemon-spawn
-  requirement: &10279380 !ruby/object:Gem::Requirement
+  requirement: &10450660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10279380
+  version_requirements: *10450660
 - !ruby/object:Gem::Dependency
   name: iobuffer
-  requirement: &10295080 !ruby/object:Gem::Requirement
+  requirement: &10450060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10295080
+  version_requirements: *10450060
 description: Stand alone push notification server for APN, GCM, WNS and MPNS.
 email:
 - rd@skillupjapan.co.jp, n.bersano@skillupchile.cl
@@ -86,6 +86,7 @@ files:
 - lib/suj/pusher/gcm_connection.rb
 - lib/suj/pusher/logger.rb
 - lib/suj/pusher/monkey/hash.rb
+- lib/suj/pusher/monkey/vash.rb
 - lib/suj/pusher/version.rb
 - lib/suj/pusher/wns_connection.rb
 - lib/suj/pusher/wns_notification.rb