mercurius 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65ff200559fb5130010b47d7d2be2cc1e524b0de
-  data.tar.gz: 8a28049240b58317298775619721978b80cb7ce7
+  metadata.gz: bba600c5ea9ccfe58f1be1c8a0190f76ed156876
+  data.tar.gz: 878a4fbc8539723e11c8b489a6335fa1e0839e88
 SHA512:
-  metadata.gz: ce55894987fecb4a496c014681d07dbea9375e805e2a1523b2d2495fe09a8bfb9a13254f6a78fd720ab3d994311903c5a0ace2415a2edf8b21b7b81dfaf10bd1
-  data.tar.gz: 334217c4278902311a45fed9ae873b912246354f25972d04dab17356fdca3f68fd0d6d0a214f103d7fd399d617253d99858ddc35a3bc19038d0c7edadbb34173
+  metadata.gz: a80bcb308c866c6d4b98beb7ea1ec19e7407c306f6ec6fa322dd40388973473324363dbf6d26432ff8aeea0f57fb492086c4b6e87d2ed50be1e8ba0982b09502
+  data.tar.gz: f63ae742964e49c26bb46ada8088dc77cdb94539663ecef72ffa63fcb0232a1945caed3ce11eedb63b516db770ff85de4d63ff865fb8a8995fa14d1f4dc2161d

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.5
+2.1.5

data/lib/mercurius/apns/connection.rb

@@ -0,0 +1,37 @@
+module APNS
+  class Connection
+    attr_reader :host, :port, :ssl
+
+    def initialize(host, port, pem)
+      @socket = TCPSocket.new host, port
+      @ssl = OpenSSL::SSL::SSLSocket.new @socket, ssl_context_for_pem(pem)
+    end
+
+    def open
+      @ssl.connect
+    end
+
+    def close
+      @ssl.close
+      @socket.close
+    end
+
+    def closed?
+      @ssl.closed? && @socket.closed?
+    end
+
+    def write(data)
+      @ssl.write data
+    end
+
+    private
+
+      def ssl_context_for_pem(pem)
+        context = OpenSSL::SSL::SSLContext.new
+        context.cert = OpenSSL::X509::Certificate.new(pem.data)
+        context.key = OpenSSL::PKey::RSA.new(pem.data, pem.password)
+        context
+      end
+
+  end
+end

data/lib/mercurius/apns/notification.rb

@@ -1,46 +1,46 @@
 module APNS
   class Notification
-    attr_accessor :device_token, :alert, :badge, :sound, :other
-
-    def initialize(device_token, message)
-      self.device_token = device_token
-      if message.is_a?(Hash)
-        self.alert = message[:alert]
-        self.badge = message[:badge]
-        self.sound = message[:sound]
-        self.other = message[:other]
-      elsif message.is_a?(String)
-        self.alert = message
-      else
-        raise "Notification needs to have either a Hash or String"
-      end
+    include ActiveModel::Model
+
+    MAX_PAYLOAD_BYTES = 2048
+
+    attr_accessor :alert, :badge, :sound, :other
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      super
     end
 
-    def packaged_notification
-      pt = self.packaged_token
-      pm = self.packaged_message
-      [0, 0, 32, pt, 0, pm.bytesize, pm].pack("ccca*cca*")
+    def payload
+      {
+        alert: alert,
+        badge: badge,
+        sound: sound,
+        other: other
+      }.compact
     end
 
-    def packaged_token
+    def pack(device_token)
+      [0, 0, 32, package_device_token(device_token), 0, packaged_message.bytesize, packaged_message].pack("ccca*cca*")
+    end
+
+    def package_device_token(device_token)
       [device_token.gsub(/[\s|<|>]/,'')].pack('H*')
     end
 
     def packaged_message
-      aps = {'aps'=> {} }
-      aps['aps']['alert'] = self.alert if self.alert
-      aps['aps']['badge'] = self.badge if self.badge
-      aps['aps']['sound'] = self.sound if self.sound
-      aps.merge!(self.other) if self.other
-      aps.to_json.gsub(/\\u([\da-fA-F]{4})/) {|m| [$1].pack("H*").unpack("n*").pack("U*")}
+      { aps: payload }.to_json.gsub(/\\u([\da-fA-F]{4})/) do |m|
+        [$1].pack("H*").unpack("n*").pack("U*")
+      end
     end
 
     def ==(that)
-      device_token == that.device_token &&
-      alert == that.alert &&
-      badge == that.badge &&
-      sound == that.sound &&
-      other == that.other
+      attributes == that.attributes
+    end
+
+    def valid?
+      packaged_message.bytesize <= MAX_PAYLOAD_BYTES
     end
 
   end

data/lib/mercurius/apns/pem.rb

@@ -0,0 +1,22 @@
+module APNS
+  class Pem
+    include ActiveModel::Model
+
+    attr_accessor :path, :data, :password
+
+    def data
+      @_data ||= (@data || read_file_at_path || raise(PemNotConfiguredError.new))
+    end
+
+    private
+
+      def read_file_at_path
+        if File.exist? path
+          File.read path
+        else
+          raise PemNotFoundError.new
+        end
+      end
+
+  end
+end

data/lib/mercurius/apns/service.rb

@@ -0,0 +1,62 @@
+module APNS
+  class Service
+    include ActiveModel::Model
+
+    MAX_NUMBER_OF_RETRIES = 3
+
+    attr_accessor :host, :port, :pem
+    attr_reader :connection, :attempts
+
+    def initialize(*)
+      super
+      @host ||= APNS.host
+      @port ||= APNS.port
+      @pem  ||= APNS.pem
+      @connection = APNS::Connection.new(@host, @port, @pem)
+      @attempts = 0
+    end
+
+    def persist(&block)
+      @_persistent = true
+      yield
+      @_persistent = false
+      connection.close
+    end
+
+    def deliver(notification, *device_tokens)
+      device_tokens = Array(device_tokens).flatten
+      with_connection do |connection|
+        device_tokens.each do |device_token|
+          connection.write notification.pack(device_token)
+        end
+      end
+    end
+
+    private
+
+      def persistent?
+        @_persistent
+      end
+
+      def with_connection(&block)
+        @attempts = 1
+
+        begin
+          connection.open if connection.closed?
+          yield connection
+        rescue StandardError, Errno::EPIPE => e
+          raise TooManyRetriesError.new if too_many_retries?
+          connection.close
+          @attempts += 1
+          retry
+        end
+
+        connection.close unless persistent?
+      end
+
+      def too_many_retries?
+        @attempts >= MAX_NUMBER_OF_RETRIES
+      end
+
+  end
+end

data/lib/mercurius/apns.rb

@@ -0,0 +1,10 @@
+module APNS
+  @host = ''
+  @port = 2195
+  @pem = nil
+
+  class << self
+    attr_accessor :host, :port, :pem
+  end
+
+end

data/lib/mercurius/errors/pem_not_configured_error.rb

@@ -0,0 +1,7 @@
+class PemNotConfiguredError < StandardError
+
+  def initialize
+    super 'PEM is not configured properly.'
+  end
+
+end

data/lib/mercurius/errors/pem_not_found_error.rb

@@ -0,0 +1,7 @@
+class PemNotFoundError < StandardError
+
+  def initialize
+    super 'The specified PEM file does not exist.'
+  end
+
+end

data/lib/mercurius/errors/too_many_retries_error.rb

@@ -0,0 +1,7 @@
+class TooManyRetriesError < StandardError
+
+  def initialize
+    super "APNS Service has reached it's maximum number of retries"
+  end
+
+end

data/lib/mercurius/gcm/connection.rb

@@ -0,0 +1,24 @@
+module GCM
+  class Connection
+
+    attr_accessor :host, :key
+
+    def initialize(host, key)
+      @host = host
+      @key = key
+    end
+
+    def write(json)
+      client.post '/gcm/send', json
+    end
+
+    def client
+      @_client ||= Faraday.new(host) do |http|
+        http.headers['Authorization'] = "key=#{key}"
+        http.request :json
+        http.adapter :net_http
+      end
+    end
+
+  end
+end

data/lib/mercurius/gcm/notification.rb

@@ -1,54 +1,30 @@
 module GCM
   class Notification
-    attr_accessor :device_tokens, :data, :collapse_key, :time_to_live, :delay_while_idle, :identity
+    include ActiveModel::Model
 
-    def initialize(tokens, data, options = {})
-      self.device_tokens = tokens
-      self.data = data
+    attr_accessor :data, :collapse_key, :time_to_live, :delay_while_idle
 
-      @collapse_key = options[:collapse_key]
-      @time_to_live = options[:time_to_live]
-      @delay_while_idle = options[:delay_while_idle]
-      @identity = options[:identity]
-    end
-
-    def device_tokens=(tokens)
-      if tokens.is_a?(Array)
-        @device_tokens = tokens
-      elsif tokens.is_a?(String)
-        @device_tokens = [tokens]
-      else
-        raise "device_tokens needs to be either an Array or a String"
-      end
-    end
+    # validate delay_while_idle is true/false
+    # validate ttl is integer in seconds
 
-    def data=(data)
-      if data.is_a?(Hash)
-        @data = data
-      else
-        raise "data parameter must be the type of Hash"
-      end
+    def initialize(attributes = {})
+      @attributes = attributes
+      super data: @attributes.except(:collapse_key, :time_to_live, :delay_while_idle)
     end
 
-    def delay_while_idle=(delay_while_idle)
-      @delay_while_idle = (delay_while_idle == true || delay_while_idle == :true)
-    end
+    def to_h
+      hash = {
+        data: data,
+        collapse_key: collapse_key,
+        time_to_live: time_to_live,
+        delay_while_idle: delay_while_idle
+      }
 
-    def time_to_live=(time_to_live)
-      if time_to_live.is_a?(Integer)
-        @time_to_live = time_to_live
-      else
-        raise %q{"time_to_live" must be seconds as an integer value, like "100"}
-      end
+      hash.reject { |k, v| v.nil? }
     end
 
     def ==(that)
-      device_tokens == that.device_tokens &&
-      data == that.data &&
-      collapse_key == that.collapse_key &&
-      time_to_live == that.time_to_live &&
-      delay_while_idle == that.delay_while_idle &&
-      identity == that.identity
+      attributes == that.attributes
     end
 
   end

data/lib/mercurius/gcm/response.rb

@@ -0,0 +1,35 @@
+module GCM
+  class Response
+    attr_reader :response, :device_tokens
+
+    MESSAGES = {
+      200 => 'Success',
+      400 => 'The request could not be parsed as JSON or it contained invalid fields',
+      401 => 'There was an error authenticating the sender account',
+      500 => 'There was an internal error in the GCM server',
+      503 => 'GCM server is temporarily unavailable',
+      default: 'Unknown error'
+    }
+
+    def initialize(response, device_tokens)
+      @response = response
+      @device_tokens = device_tokens
+    end
+
+    def status
+      @response.status
+    end
+
+    def message
+      MESSAGES.fetch(status, MESSAGES[:default])
+    end
+
+    def success?
+      @response.success?
+    end
+
+    def failed?
+      !success?
+    end
+  end
+end

data/lib/mercurius/gcm/result.rb

@@ -0,0 +1,27 @@
+module GCM
+  class Result
+    attr_reader :responses
+
+    def initialize(notification)
+      @notification = notification
+      @responses = []
+    end
+
+    def success?
+      failed_responses.empty?
+    end
+
+    def process_response(response, device_tokens)
+      self.responses << GCM::Response.new(response, device_tokens)
+    end
+
+    def failed_responses
+      @_failed_responses ||= responses.select(&:failed?)
+    end
+
+    def failed_device_tokens
+      @_failed_device_tokens ||= failed_responses.flat_map { |response| response.device_tokens }
+    end
+
+  end
+end

data/lib/mercurius/gcm/service.rb

@@ -0,0 +1,36 @@
+module GCM
+  class Service
+    include ActiveModel::Model
+
+    MAX_NUMBER_OF_RETRIES = 3
+    MAX_DEVICES_AT_ONCE = 999
+
+    attr_accessor :host, :key
+    attr_reader :connection, :attempts
+
+    def initialize(*)
+      super
+      @host ||= GCM.host
+      @key  ||= GCM.key
+      @connection = GCM::Connection.new(@host, @key)
+      @attempts = 0
+    end
+
+    def deliver(notification, *device_tokens)
+      result = GCM::Result.new(notification)
+      device_tokens = Array(device_tokens).flatten
+      device_tokens.each_slice(MAX_DEVICES_AT_ONCE) do |tokens|
+        payload = notification.to_h.merge registration_ids: tokens
+        result.process_response connection.write(payload), tokens
+      end
+      result
+    end
+
+    private
+
+      def too_many_retries?
+        @attempts >= MAX_NUMBER_OF_RETRIES
+      end
+
+  end
+end

data/lib/mercurius/gcm.rb

@@ -0,0 +1,9 @@
+module GCM
+  @host = 'https://android.googleapis.com/'
+  @key = ENV['GCM_KEY']
+
+  class << self
+    attr_accessor :host, :key
+  end
+
+end

data/lib/mercurius/version.rb

@@ -1,3 +1,3 @@
 module Mercurius
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/mercurius.rb

@@ -1,3 +1,25 @@
-require "mercurius/version"
-require "mercurius/apple"
-require "mercurius/android"
+require 'active_model'
+require 'active_support/core_ext/hash/compact'
+require 'active_support/core_ext/hash/except'
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+
+require 'mercurius/version'
+
+require 'mercurius/errors/pem_not_configured_error'
+require 'mercurius/errors/pem_not_found_error'
+require 'mercurius/errors/too_many_retries_error'
+
+require 'mercurius/apns'
+require 'mercurius/apns/pem'
+require 'mercurius/apns/connection'
+require 'mercurius/apns/notification'
+require 'mercurius/apns/service'
+
+require 'mercurius/gcm'
+require 'mercurius/gcm/connection'
+require 'mercurius/gcm/notification'
+require 'mercurius/gcm/service'
+require 'mercurius/gcm/response'
+require 'mercurius/gcm/result'

data/mercurius.gemspec

@@ -22,9 +22,13 @@ Gem::Specification.new do |s|
 
   s.require_paths = ["lib"]
 
-  s.add_dependency 'httparty'
   s.add_dependency 'json'
+  s.add_dependency 'faraday'
+  s.add_dependency 'faraday_middleware'
+  s.add_dependency 'activemodel', '>= 4.0.0'
+  s.add_dependency 'activesupport', '>= 4.1.0'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
+  s.add_development_dependency 'webmock'
 end

data/spec/lib/apns_service_spec.rb

@@ -0,0 +1,70 @@
+describe APNS::Service do
+  let(:service) { APNS::Service.new }
+
+  before do
+    # setup APNS
+    bundle = File.read File.expand_path(File.join(File.dirname(__FILE__), '..', 'support', 'apns.pem'))
+    APNS.host = 'gateway.sandbox.push.apple.com'
+    APNS.port = 2195
+    APNS.pem = APNS::Pem.new(data: bundle, password: 'test123')
+  end
+
+  it 'should default to the APNS module configs' do
+    expect(service.host).to eq 'gateway.sandbox.push.apple.com'
+    expect(service.port).to eq 2195
+    expect(service.pem.password).to eq 'test123'
+  end
+
+  describe '#send' do
+    let(:ssl) { FakeSocket.new }
+    let(:socket) { FakeSocket.new }
+
+    before do
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new) { ssl }
+      expect(TCPSocket).to receive(:new) { socket }
+    end
+
+    it 'sends a single message' do
+      message = APNS::Notification.new(alert: 'Hey')
+      service.deliver message, 'token123'
+      expect(ssl.wrote[0]).to include ({ alert: 'Hey' }).to_json
+    end
+
+    it 'sends to multiple tokens via splat' do
+      message = APNS::Notification.new(alert: 'Hey')
+      service.deliver message, 'token123', 'token456'
+      expect(ssl.wrote.size).to eq 2
+    end
+
+    it 'sends to multiple token via array' do
+      message = APNS::Notification.new(alert: 'Hey1')
+      service.deliver message, ['token123', 'token456']
+      expect(ssl.wrote.size).to eq 2
+    end
+
+    describe 'persist' do
+      it 'with persist, it keeps the SSL connection open until all messages are sent' do
+        expect(service.connection).to receive(:close).once
+        service.persist do
+          service.deliver APNS::Notification.new(alert: 'Hey1'), 'token123'
+          service.deliver APNS::Notification.new(alert: 'Hey2'), 'token123'
+        end
+      end
+
+      it 'without persist, closes the connection on each message' do
+        expect(service.connection).to receive(:close).twice
+        service.deliver APNS::Notification.new(alert: 'Hey1'), 'token123'
+        service.deliver APNS::Notification.new(alert: 'Hey2'), 'token123'
+      end
+    end
+
+    describe 'retries' do
+      it 'tries 3 times before giving up' do
+        allow(service.connection).to receive(:open) { raise StandardError }
+        expect { service.deliver APNS::Notification.new(alert: 'Hey1'), 'token123' }.to raise_exception(TooManyRetriesError)
+        expect(service.attempts).to eq 3
+      end
+    end
+
+  end
+end

data/spec/lib/gcm_service_spec.rb

@@ -0,0 +1,72 @@
+describe GCM::Service do
+  let(:service) { GCM::Service.new }
+  let(:message) { GCM::Notification.new(alert: 'Hey') }
+
+  it 'should default to the GCM module configs' do
+    expect(service.host).to eq 'https://android.googleapis.com/'
+    expect(service.key).to be_nil
+  end
+
+  describe '#send' do
+    before { stub_request :post, %r[android.googleapis.com/gcm/send] }
+
+    it 'sends a single message' do
+      service.deliver message, 'token123'
+      expect(WebMock).to have_requested(:post, %r[android.googleapis.com/gcm/send]).
+        with(body: { data: { alert: 'Hey' }, registration_ids: ['token123'] })
+    end
+
+    it 'sends to multiple tokens via splat' do
+      service.deliver message, 'token123', 'token456'
+      expect(WebMock).to have_requested(:post, %r[android.googleapis.com/gcm/send]).
+        with(body: { data: { alert: 'Hey' }, registration_ids: ['token123', 'token456'] })
+    end
+
+    it 'sends to multiple tokens via array' do
+      service.deliver message, ['token123', 'token456']
+      expect(WebMock).to have_requested(:post, %r[android.googleapis.com/gcm/send]).
+        with(body: { data: { alert: 'Hey' }, registration_ids: ['token123', 'token456'] })
+    end
+
+    it 'only sends 999 tokens at a time' do
+      tokens = (1..1000).to_a.map { |i| "token#{i}" }
+      service.deliver message, tokens
+      expect(WebMock).to have_requested(:post, %r[android.googleapis.com/gcm/send]).
+        with(body: { data: { alert: 'Hey' }, registration_ids: tokens.take(999) })
+      expect(WebMock).to have_requested(:post, %r[android.googleapis.com/gcm/send]).
+        with(body: { data: { alert: 'Hey' }, registration_ids: [tokens.last] })
+    end
+  end
+
+  describe 'response' do
+    context 'success' do
+      before { stub_request :post, %r[android.googleapis.com/gcm/send] }
+
+      it 'processes a 200 response' do
+        result = service.deliver message, 'token123'
+        expect(result.responses[0].status).to eq 200
+        expect(result.responses[0].message).to eq GCM::Response::MESSAGES[200]
+        expect(result.failed_device_tokens).to eq []
+      end
+    end
+
+    context 'failure' do
+      before { stub_request(:post, %r[android.googleapis.com/gcm/send]).to_return(status: 400) }
+
+      it 'processes a 400 response' do
+        result = service.deliver message, 'token123'
+        expect(result.responses[0].status).to eq 400
+        expect(result.responses[0].message).to eq GCM::Response::MESSAGES[400]
+        expect(result.failed_device_tokens).to eq ['token123']
+      end
+
+      it 'adds all failed messages to the failed device tokens array' do
+        tokens = (1..1000).to_a.map { |i| "token#{i}" }
+        result = service.deliver message, tokens
+        expect(result.failed_device_tokens).to include 'token1'
+        expect(result.failed_device_tokens).to include 'token1000'
+      end
+    end
+
+  end
+end