higcm 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    gcm (0.0.1)
+      typhoeus (~> 0.3.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    json (1.7.3)
+    mime-types (1.19)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    typhoeus (0.3.3)
+      mime-types
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gcm!
+  json
+  rake
+  rspec (~> 2.6)

data/README.md

@@ -0,0 +1,79 @@
+GCM Ruby wrapper  [![Build Status](https://secure.travis-ci.org/hifrank/higcm.png?branch=master)](http://travis-ci.org/hifrank/higcm)
+===
+This is Ruby libray for push message to device via [Google Cloud Messaging for Android](http://developer.android.com/guide/google/gcm/index.html)
+# Features
+## parallel gcm messaging 
+use [Typhoeus](http://typhoeus.github.com/) as http client so it is able to send gcm messges in parallel way.
+
+## handler
+parse gcm response with GCM::Handler according to [GCM Response format](http://developer.android.com/guide/google/gcm/gcm.html#response), 
+into serveral kinds of responses, say, success, fails, retry, unregister, you can only handle events you care about.
+
+# Usage
+
+## send a message
+<code>
+sender = HiGCM::Sender.new(your_api_key)
+registration_ids = [1, 2, 3]
+opts = {
+  :collapse_key => "test"
+  :data         => { :mesg => "hello GCM" }
+}
+response = sender.send(registration_ids, opts)
+...
+</code>
+
+## send a message with handler
+<code>
+# prepare handler for retry and unregister event
+handler = HiGCM::Handler.new
+handler.do_retry do | retry_ids, opts, response |
+  retry_ids.each do | reg_id, retry_after |
+    # do retry things
+  end
+end
+#prepare for renew registration_ids 
+handler.do_renew_token do | renew_ids, response |
+  renew_ids.each do | reg_id, new_reg_id |
+    # do renew stuff
+  end
+end
+
+sender  = HiGCM::Sender.new(your_api_key)
+registration_ids = [1, 2, 3]
+opts = {
+  :collapse_key => "test"
+  :data         => { :mesg => "hello GCM" }
+}
+sender.send(registration_ids, opts)
+</code>
+
+## send a muti-messages in parallel way 
+<code>
+sender  = HiGCM::Sender.new(your_api_key)
+
+# queue your messages first 
+something.each do | registration_id, name |
+  # prepare handler for retry and unregister event
+  handler = HiGCM::Handler.new
+  handler.do_retry do | retry_ids, opts, response |
+    retry_ids.each do | reg_id, retry_after |
+      # do retry things
+    end
+  end
+  #prepare for renew registration_ids 
+  handler.do_renew_token do | renew_ids, response |
+    renew_ids.each do | reg_id, new_reg_id |
+      # do renew stuff
+    end
+  end
+
+  opts = {
+    :collapse_key => "test"
+    :data         => { :mesg => "hello #{name}" }
+  }
+  sender.send_async(registration_id, opts, handler)
+end
+# now fire
+sender.send_async_run
+</code>

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/higcm.gemspec

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name         = "higcm"
+  s.version      = "0.0.1"
+  s.authors      = ["hifrank"]
+  s.email        = "frank_chen@htc.com"
+  s.homepage     = "https://github.com/hifrank/higcm"
+  s.summary      = "ruby wrapper for GCM google cloud messaging."
+  s.description  = %q{ruby wrapper for GCM google cloud messaging.}
+  #s.extensions   = [""]
+  s.files        = (`git ls-files ext lib spec`.split("\n")) + [
+                     'README.md',
+                     'Gemfile',
+                     'Gemfile.lock',
+                     'Rakefile',
+                     'higcm.gemspec'
+                   ]
+  s.platform     = Gem::Platform::RUBY
+  s.require_path = 'lib'
+  s.rubyforge_project = '[none]'
+
+  s.add_runtime_dependency 'typhoeus', ['~> 0.3.3']
+  s.add_development_dependency 'rspec', ["~> 2.6"]
+  s.add_development_dependency 'json', [">= 0"]
+  s.add_development_dependency 'rake', [">= 0"]
+end
+

data/lib/higcm/handler.rb

@@ -0,0 +1,105 @@
+require 'json'
+
+module HiGCM
+
+  class Handler
+
+    attr_accessor :retry_conditions
+
+    def initialize
+      @retry_ids   = {}
+      @fail_ids    = {} 
+      @success_ids = {} 
+      @renew_ids  = {}
+      @retry_conditions =[ 'InternalServerError', 'Timout', 'Unavailable' ]
+      @unregister_conditions = [ 'NotRegistered', 'InvalidRegistration' ]
+    end
+
+    def handle(registration_ids, opts, response)
+      begin
+        @code = response.code.to_i
+        @body = JSON.parse(response.body)
+        #Honor Retry-After
+        @retry_after = (response.headers['Retry-After'].nil? ? 0 : response.headers['Retry-After']) 
+      rescue Exception => e
+        @code = 99
+        @error_message = "unexpected error, response: #{response.body}, exception: #{e.inspect}"
+      end
+      case @code
+      when 200
+        #200 Message was processed successfully. The response body will contain more details about the message status, but its format will depend whether the request was JSON or plain text. See Interpreting a success response for more details.
+        # handle success case, http://developer.android.com/guide/google/gcm/gcm.html#success
+        @body['results'].each_with_index do | rs, index |
+          reg_id = registration_ids[index]
+          #handle fail
+          if rs.key?('error')
+            @error_message = rs['error']
+            if @retry_conditions.include?(rs['error'])
+              @retry_ids[reg_id] = @retry_after
+              @error_message << ", retry after #{@retry_after}"
+            end
+            @fail_ids[reg_id] = @error_message
+          #handle success
+          elsif rs.key?('message_id')
+            @success_ids[reg_id] = rs['message_id']
+            if rs.key?('registration_id')
+              @renew_ids[reg_id] = rs['registration_id']
+            end
+          else
+            #should not jump here
+          end
+        end
+        @do_success.call(@success_ids, response)         if @success_ids.count > 0 && @do_success
+        @do_fail.call(@fail_ids, response)               if @fail_ids.count > 0 && @do_fail
+        @do_renew_token.call(@renew_ids, response)       if @renew_ids.count > 0 && @do_renew_token
+        @do_retry.call(@retry_ids, opts, response) if @retry_ids.count > 0 && @do_retry
+      #TODO need to check what kinf of response will return
+      when 400, 401
+        #400 Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields (for instance, passing a string where a number was expected). The exact failure reason is described in the response and the problem should be addressed before the request can be retried.
+        #401 There was an error authenticating the sender account.
+        registration_ids.each do | reg_id |
+          if 400 == @code 
+            error_message = 'request could not be parsed as JSON'
+          else
+            error_message = 'There was an error authenticating the sender account'
+          end
+          @fail_ids[reg_id] = error_message
+        end
+        @do_fail.call(@fail_ids, response) if @do_fail &&  @fail_ids.count > 0
+      #TODO need to check what kinf of response will return
+      when 500, 503
+        #500 There was an internal error in the GCM server while trying to process the request. trouble shooting http://developer.android.com/guide/google/gcm/gcm.html#internal_error
+        #503 Indicates that the server is temporarily unavailable (i.e., because of timeouts, etc ). Sender must retry later, honoring any Retry-After header included in the response. Application servers must implement exponential back-off. The GCM server took too long to process the request. Troubleshoot
+        registration_ids.each do | reg_id |
+          @retry_ids[reg_id] = @retry_after
+        end
+        @do_retry.call(@retry_ids, opts) if @do_retry && @retry_ids.count > 0
+      else
+        registration_ids.each do | reg_id |
+          @fail_ids[reg_id] = @error_message
+        end
+        @do_fail.call(@fail_ids, response) if @do_fail && @fail_ids.count > 0
+      end
+    end
+
+    # success_ids
+    def do_success(&block)
+      @do_success = block
+    end
+
+    # retry_ids, opts, retry_after
+    def do_retry(&block)
+      @do_retry = block
+    end
+
+    def do_fail(&block)
+      @do_fail = block
+    end
+
+    # renew_ids(hash)
+    def do_renew_token(&block)
+      @do_renew_token = block
+    end
+
+  end
+end

data/lib/higcm/sender.rb

@@ -0,0 +1,73 @@
+require 'typhoeus'
+
+module HiGCM
+
+    class SenderError < StandardError; end
+
+    class Sender
+      attr_accessor :api_key, :api_status, :hydra, :requests
+
+      OPTIONAL_OPTIONS = {
+        :collapse_key     => String, 
+        :data             => Hash, 
+        :delay_while_idle => Fixnum, 
+        :time_to_live     => Fixnum
+      }
+
+      def initialize(api_key)
+        @api_key  = api_key
+        raise SenderError.new("api_key is necessary for #{self.class}") if api_key.nil? || api_key.empty?
+      end
+
+      def send(registration_ids, opts={}, handler=nil)
+        request = send_async(registration_ids, opts, handler)
+        send_async_run
+        request.handled_response
+      end
+
+      #http://developer.android.com/guide/google/gcm/gcm.html#server
+      def send_async(registration_ids, opts={}, handler=nil)
+
+        headers = {
+          'Content-Type'  => 'application/json',
+          'Authorization' => sprintf("key=%s", @api_key)
+        }
+
+        body = {
+          'registration_ids' => registration_ids,
+        }
+
+        #fill up option
+        OPTIONAL_OPTIONS.each do | key, type |
+          if opts.key?(key)
+            raise SenderError.new("#{key} should be Type #{type}") unless opts[key].is_a?(type)
+            body[key] = opts[key]
+          end
+        end
+
+        request = Typhoeus::Request.new(
+          'https://android.googleapis.com/gcm/send',
+          :headers         => headers,
+          :method          => :post,
+          :body            => body.to_json,
+          :follow_location => true
+        )
+
+        @hydra ||= Typhoeus::Hydra.new
+
+        request.on_complete do | response |
+          handler.handle(registration_ids, opts, response)
+        end
+
+        @hydra.queue(request)
+
+        request
+      end
+
+      def send_async_run
+        # handle response according to http://developer.android.com/guide/google/gcm/gcm.html#response
+        @hydra.run
+      end
+
+    end
+end

data/lib/higcm.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+require 'typhoeus'
+require 'higcm/sender'
+require 'higcm/handler'
+
+module HiGCM
+end

data/spec/fixtures/gcm_response_200.json

@@ -0,0 +1,13 @@
+{ "multicast_id": 216,
+  "success": 3,
+  "failure": 3,
+  "canonical_ids": 1,
+  "results": [
+    { "message_id": "1:0408" },
+    { "error": "Unavailable" },
+    { "error": "InvalidRegistration" },
+    { "message_id": "1:1516" },
+    { "message_id": "1:2342", "registration_id": "32" },
+    { "error": "NotRegistered"}
+  ]
+}

data/spec/lib/higcm/handler_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe HiGCM::Handler do
+  it "#handle should handle various response in when response code is 500" do
+  end
+
+  it "#handle should handle various response when response code is 200" do
+    @raw_gcm_response = File.read("#{File.dirname(__FILE__)}/../../fixtures/gcm_response_200.json")
+    @retry_after = 10
+    @stub_gcm_response = Typhoeus::Response.new(
+      :code    => 200,
+      :headers => {"Retry-After" => @retry_after},
+      :body    =>  @raw_gcm_response,
+      :time    => 0.1
+    )
+    @api_key     = 'foo'
+    sender       = HiGCM::Sender.new(@api_key)
+    sender.hydra = Typhoeus::Hydra.hydra
+    sender.hydra.stub(:post, 'https://android.googleapis.com/gcm/send').and_return(@stub_gcm_response)
+
+    _fails   = 0
+    _success = 0
+    _renew   = 0
+    _retry   = 0
+
+    _updated_token = { 5 => "32"}
+
+    handler = HiGCM::Handler.new
+    handler.do_success do | succes_ids, response |
+      @success_ids      = succes_ids
+      @success_response = response   
+    end
+    handler.do_retry do | retry_ids, opts, response |
+      @retry_ids      = retry_ids
+      @retry_opts     = opts
+      @retry_response = response
+    end
+    handler.do_fail do | fail_ids, response |
+      @fail_ids      = fail_ids
+      @fail_response = response
+    end
+    handler.do_renew_token do | renew_ids, response |
+      @renew_ids      = renew_ids
+      @renew_response = response
+    end
+
+    registration_ids = [1, 2, 3, 4, 5, 6]
+    sender.send_async(registration_ids, {}, handler)
+    sender.send_async_run
+
+    @fail_ids.should == { 2 => "Unavailable, retry after #{@retry_after}", 3 => "InvalidRegistration", 6 => "NotRegistered" } 
+    @fail_response.is_a?(Typhoeus::Response).should == true
+
+    @retry_ids.should  == { 2 => 10 } 
+    @retry_opts.should == {} 
+    @retry_response.is_a?(Typhoeus::Response).should == true
+
+    @renew_ids.should == { 5 => "32" } 
+    @renew_response.is_a?(Typhoeus::Response).should == true
+
+    @success_ids.should == { 1 => "1:0408", 4 => "1:1516", 5 => "1:2342" } 
+    @success_response.is_a?(Typhoeus::Response).should == true
+
+  end
+
+end

data/spec/lib/higcm/sender_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe HiGCM::Sender do
+
+  before(:each) do
+    @api_key = 'foo'
+    @registration_ids = [1, 2, 3, 4, 5, 6]
+    @raw_gcm_response = File.read("#{File.dirname(__FILE__)}/../../fixtures/gcm_response_200.json")
+    @retry_after = 10
+    @stub_gcm_response = Typhoeus::Response.new(
+      :code    => 200,
+      :headers => {"Retry-After" => @retry_after},
+      :body    =>  @raw_gcm_response,
+      :time    => 0.1
+    )
+    @sender = HiGCM::Sender.new(@api_key)
+    @sender.hydra = Typhoeus::Hydra.new
+    @sender.hydra.stub(:post, 'https://android.googleapis.com/gcm/send').and_return(@stub_gcm_response)
+  end
+
+  describe "#initialize" do
+    it "should raise exception when api_key does not given when init" do
+      expect { sender = HiGCM::Sender.new }.to raise_error
+    end
+
+    it "should raise exception when given api_key is nil or empty" do
+      expect { sender = HiGCM::Sender.new ""}.to raise_error
+      expect { sender = HiGCM::Sender.new nil}.to raise_error
+    end
+
+    it "should raise exception when given api_key is nil or empty" do
+      sender  = HiGCM::Sender.new(@api_key)
+      sender.is_a?(HiGCM::Sender).should == true
+      sender.api_key.should            == @api_key
+    end
+  end
+
+  describe "#send" do
+    it "should return Typhoeus::Request" do
+      response = @sender.send_async(@registration_ids, {})
+      response.class.should == Typhoeus::Request
+    end
+
+    it "should call handler.handle after request is completed" do
+      handler = double(HiGCM::Handler)
+      handler.should_receive(:handle).with(@registration_ids, {}, @stub_gcm_response)
+      @sender.send(@registration_ids, {}, handler)
+    end
+  end
+
+  describe "#send_async" do
+
+    it "should call handler.handle after request is completed" do
+      handler = double(HiGCM::Handler)
+      handler.should_receive(:handle).with(@registration_ids, {}, @stub_gcm_response)
+      @sender.send_async(@registration_ids, {}, handler)
+      @sender.send_async_run
+    end
+
+    it "should raise exception if opts[:collapse_key] is not String, empty string is acceptable" do
+      expect { @sender.send_async(@registration_ids, {:collapse_key => nil }, HiGCM::Handler.new) }.to raise_error(HiGCM::SenderError)
+      expect { @sender.send_async(@registration_ids, {:collapse_key => "" }, HiGCM::Handler.new) }.not_to raise_error(HiGCM::SenderError)
+    end
+
+    it "should raise exception if opts[:data] is not Hash, empty hash is acceptable" do
+      expect { @sender.send_async(@registration_ids, {:data => [] }, HiGCM::Handler.new) }.to raise_error(HiGCM::SenderError)
+      expect { @sender.send_async(@registration_ids, {:data => {} }, HiGCM::Handler.new) }.not_to raise_error(HiGCM::SenderError)
+    end
+
+    it "should raise exception if opts[:delay_while_idle] && opts[:time_to_live] is not Fixnum" do
+      expect { @sender.send_async(@registration_ids, {:delay_while_idle => [] }, HiGCM::Handler.new) }.to raise_error(HiGCM::SenderError)
+      expect { @sender.send_async(@registration_ids, {:delay_while_idle => 1 }, HiGCM::Handler.new) }.not_to raise_error(HiGCM::SenderError)
+      expect { @sender.send_async(@registration_ids, {:time_to_live => [] }, HiGCM::Handler.new) }.to raise_error(HiGCM::SenderError)
+      expect { @sender.send_async(@registration_ids, {:time_to_live => 1 }, HiGCM::Handler.new) }.not_to raise_error(HiGCM::SenderError)
+    end
+  end
+
+  describe "#send_async_run" do
+    it "should run Typhoeus::Hydra when send requests" do
+      hydra  = double(Typhoeus::Hydra)
+      @sender.hydra = hydra
+      hydra.should_receive(:run).once
+      @sender.send_async_run
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "rubygems"
+require 'json'
+require "rspec"
+
+# gem install redgreen for colored test output
+begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
+
+path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
+
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+
+require 'higcm'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: higcm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- hifrank
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: &2177156140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2177156140
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2177142980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *2177142980
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2177142280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2177142280
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2177141340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2177141340
+description: ruby wrapper for GCM google cloud messaging.
+email: frank_chen@htc.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/higcm.rb
+- lib/higcm/handler.rb
+- lib/higcm/sender.rb
+- spec/fixtures/gcm_response_200.json
+- spec/lib/higcm/handler_spec.rb
+- spec/lib/higcm/sender_spec.rb
+- spec/spec_helper.rb
+- README.md
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- higcm.gemspec
+homepage: https://github.com/hifrank/higcm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ! '[none]'
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ruby wrapper for GCM google cloud messaging.
+test_files: []