pling 0.0.1 → 0.1.0

data/lib/pling/gateway/apn.rb

@@ -0,0 +1,85 @@
+require 'socket'
+require 'openssl'
+require 'json'
+
+module Pling
+  module Gateway
+    ##
+    # Pling gateway to communicate with Apple's Push Notification service.
+    #
+    # This gateway handles these device types: 
+    #     :apple, :apn, :ios, :ipad, :iphone, :ipod
+    #
+    # Configure it by providing the path to your certificate:
+    #
+    #     Pling::Gateway::APN.new({
+    #       :certificate => '/path/to/certificate.pem', # Required
+    #       :host => 'gateway.sandbox.push.apple.com'   # Optional
+    #     })
+    #
+    class APN < Base
+      handles :apple, :apn, :ios, :ipad, :iphone, :ipod
+
+      ##
+      # Initializes a new gateway to Apple's Push Notification service
+      #
+      # @param [Hash] configuration
+      # @option configuration [#to_s] :certificate Path to PEM certificate file (Required)
+      # @option configuration [String] :host Host to connect to (Default: gateway.push.apple.com)
+      # @option configuration [Integer] :port Port to connect to (Default: 2195)
+      def initialize(configuration)
+        super
+        require_configuration(:certificate)
+        connection
+      end
+
+      ##
+      # Sends the given message to the given device without using the middleware.
+      #
+      # @param [#to_pling_message] message
+      # @param [#to_pling_device] device
+      def deliver!(message, device)
+        token = [device.identifier].pack('H*')
+
+        data = {
+          :aps => {
+            :alert => message.body
+          }
+        }.to_json
+
+        raise Pling::DeliveryFailed, "Payload size of #{data.bytesize} exceeds allowed size of 256 bytes." if data.bytesize > 256
+
+        connection.write([0, 0, 32, token, 0, data.bytesize, data].pack('ccca*cca*'))
+      end
+
+      private
+
+        def default_configuration
+          super.merge({
+            :host => 'gateway.push.apple.com',
+            :port => 2195
+          })
+        end
+
+        def connection
+          @connection ||= OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context).tap do |socket|
+            socket.sync = true
+            socket.connect
+          end
+        end
+
+        def ssl_context
+          @ssl_context ||= OpenSSL::SSL::SSLContext.new.tap do |context|
+            certificate  = File.read(configuration[:certificate])
+
+            context.cert = OpenSSL::X509::Certificate.new(certificate)
+            context.key  = OpenSSL::PKey::RSA.new(certificate)
+          end
+        end
+
+        def tcp_socket
+          @tcp_socket ||= TCPSocket.new(configuration[:host], configuration[:port])
+        end
+    end
+  end
+end

data/lib/pling/gateway/base.rb

@@ -0,0 +1,64 @@
+module Pling
+  module Gateway
+    class Base
+      include Pling::Configurable
+
+      class << self
+        def handles(*types)
+          @handled_types = [types].flatten.map { |t| t.to_sym }
+        end
+
+        def handled_types
+          @handled_types ||= []
+        end
+      end
+
+      def initialize(config = {})
+        setup_configuration(config)
+        middlewares = configuration[:middlewares]
+        configuration.merge!(:middlewares => Pling::DelayedInitializer.new)
+        middlewares.each { |middleware| configuration[:middlewares] << middleware } if middlewares
+      end
+
+      def handles?(device)
+        self.class.handled_types.include?(device.type)
+      end
+
+      ##
+      # Delivers the given message to the given device using the given stack.
+      #
+      # @param message [#to_pling_message]
+      # @param device [#to_pling_device]
+      # @param stack [Array] The stack to use (Default: configuration[:middlewares])
+      def deliver(message, device, stack = nil)
+        message = Pling._convert(message, :message)
+        device  = Pling._convert(device,  :device)
+
+        stack ||= [] + configuration[:middlewares].initialize!
+
+        return deliver!(message, device) if stack.empty?
+
+        stack.shift.deliver(message, device) do |m, d|
+          deliver(m, d, stack)
+        end
+      end
+
+      ##
+      # Delivers the given message to the given device without using the middleware.
+      #
+      # @param message [#to_pling_message]
+      # @param device [#to_pling_device]
+      def deliver!(message, device)
+        raise NotImplementedError, "Please implement #{self.class}#deliver!(message, device)"
+      end
+
+      protected
+
+        def default_configuration
+          {
+            :middlewares => Pling::DelayedInitializer.new
+          }
+        end
+    end
+  end
+end

data/lib/pling/gateway/c2dm.rb

@@ -0,0 +1,102 @@
+require 'faraday'
+
+module Pling
+  module Gateway
+    ##
+    # Pling gateway to communicate with Google's Android C2DM service.
+    #
+    # The gateway is implemented using Faraday. It defaults to Faraday's :net_http adapter.
+    # You can customize the adapter by passing the :adapter configuration.
+    #
+    # Example:
+    #
+    #   Pling::Gateway::C2DM.new({
+    #     :email    => 'your-email@gmail.com', # Your google account's email address (Required)
+    #     :password => 'your-password',        # Your google account's password (Required)
+    #     :source   => 'your-app-name',        # Your applications source identifier (Required)
+    #
+    #     :authentication_url => 'http://...', # The authentication url to use (Optional, Default: C2DM default authentication url)
+    #     :push_url           => 'http://...', # The push url to use (Optional, Default: C2DM default authentication url)
+    #     :adapter            => :net_http,    # The Faraday adapter you want to use (Optional, Default: :net_http)
+    #     :connection         => {}            # Options you want to pass to Faraday (Optional, Default: {})
+    #   })
+    class C2DM < Base
+
+      attr_reader :token
+
+      ##
+      # Initializes a new gateway to Apple's Push Notification service
+      #
+      # @param [Hash] configuration
+      # @option configuration [String] :email Your C2DM enabled Google account (Required)
+      # @option configuration [String] :password Your Google account's password (Required)
+      # @option configuration [String] :source Your applications identifier (Required)
+      # @option configuration [String] :authentication_url The URL to authenticate with (Optional)
+      # @option configuration [String] :push_url The URL to push to (Optional)
+      # @option configuration [Symbol] :adapter The Faraday adapter to use (Optional)
+      # @option configuration [String] :connection Any options for Faraday (Optional)
+      # @raise Pling::AuthenticationFailed
+      def initialize(configuration)
+        super
+        require_configuration([:email, :password, :source])
+        authenticate!
+      end
+
+      ##
+      # Sends the given message to the given device.
+      #
+      # @param [#to_pling_message] message
+      # @param [#to_pling_device] device
+      # @raise Pling::DeliveryFailed
+      def deliver!(message, device)
+        response = connection.post(configuration[:push_url], {
+          :registration_id => device.identifier,
+          :"data.body" => message.body,
+          :collapse_key => message.body.hash
+        }, { :Authorization => "GoogleLogin auth=#{@token}"})
+
+        if !response.success? || response.body =~ /^Error=(.+)$/
+          raise(Pling::DeliveryFailed, "C2DM Delivery failed: [#{response.status}] #{response.body}")
+        end
+      end
+
+      private
+
+        def authenticate!
+          response = connection.post(configuration[:authentication_url], {
+            :accountType => 'HOSTED_OR_GOOGLE',
+            :service     => 'ac2dm',
+            :Email       => configuration[:email],
+            :Passwd      => configuration[:password],
+            :source      => configuration[:source]
+          })
+
+          raise(Pling::AuthenticationFailed, "C2DM Authentication failed: [#{response.status}] #{response.body}") unless response.success?
+
+          @token = extract_token(response.body)
+        end
+
+        def default_configuration
+          super.merge({
+            :authentication_url => 'https://www.google.com/accounts/ClientLogin',
+            :push_url           => 'https://android.apis.google.com/c2dm/send',
+            :adapter            => :net_http,
+            :connection         => {}
+          })
+        end
+
+        def connection
+          @connection ||= Faraday.new(configuration[:connection]) do |builder|
+            builder.use Faraday::Request::UrlEncoded
+            builder.use Faraday::Response::Logger if configuration[:debug]
+            builder.adapter(configuration[:adapter])
+          end
+        end
+
+        def extract_token(body)
+          matches = body.match(/^Auth=(.+)$/)
+          matches ? matches[1] : raise(Pling::AuthenticationFailed, "C2DM Token extraction failed")
+        end
+    end
+  end
+end

data/lib/pling/message.rb

@@ -0,0 +1,56 @@
+module Pling
+  class Message
+    ##
+    # The message body
+    #
+    # @overload body
+    # @overload body=(body)
+    #   @param [#to_s] body
+    attr_reader :body
+
+    def body=(body)
+      body &&= body.to_s
+      @body = body
+    end
+
+    ##
+    # Creates a new Pling::Message instance with the given body
+    #
+    # @overload initialize(body)
+    #   @param [#to_s] body
+    # @overload initialize(attributes)
+    #   @param [Hash] attributes
+    #   @option attributes [#to_s] :body
+    def initialize(*args)
+      attributes = case param = args.shift
+        when String
+          (args.last || {}).merge(:body => param)
+        when Hash
+          param
+        else
+          {}
+      end
+
+      attributes.each_pair do |key, value|
+        method = "#{key}="
+        send(method, value) if respond_to?(method)
+      end
+    end
+
+    ##
+    # A message is valid if it has a body.
+    #
+    # @return [Boolean]
+    def valid?
+      !!body
+    end
+
+    ##
+    # Returns the object itself as it is already a Pling::Message.
+    #
+    # @return [Pling::Message]
+    def to_pling_message
+      self
+    end
+  end
+end

data/lib/pling/middleware.rb

@@ -0,0 +1,5 @@
+module Pling
+  module Middleware
+    autoload :Base,     'pling/middleware/base'
+  end
+end

data/lib/pling/middleware/base.rb

@@ -0,0 +1,15 @@
+module Pling
+  module Middleware
+    class Base
+      include Pling::Configurable
+
+      def initialize(configuration = {})
+        setup_configuration(configuration)
+      end
+
+      def deliver(message, device)
+        yield(message, device)
+      end
+    end
+  end
+end

data/lib/pling/version.rb

@@ -1,3 +1,3 @@
 module Pling
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/pling.gemspec

@@ -5,7 +5,7 @@ require "pling/version"
 Gem::Specification.new do |s|
   s.name        = "pling"
   s.version     = Pling::VERSION
-  s.authors     = ["benedikt", "t6d", "fabrik42"]
+  s.authors     = ["Benedikt Deicke", "Konstantin Tennhard", "Christian Bäuerlein"]
   s.email       = ["benedikt@synatic.net", "me@t6d.de", "fabrik42@gmail.com"]
   s.homepage    = "https://flinc.github.com/pling"
   s.summary     = %q{Pling is a notification framework that supports multiple gateways}
@@ -16,9 +16,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "faraday", "~> 0.7"
+  s.add_runtime_dependency "json", "~> 1.4"
+  s.add_runtime_dependency("jruby-openssl") if RUBY_PLATFORM == 'java'
 
   s.add_development_dependency "rspec", "~> 2.7"
   s.add_development_dependency "yard", ">= 0.7"

data/spec/pling/adapter/base_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Pling::Adapter::Base do
+
+  describe '.deliver' do
+
+    let(:device)  { Pling::Device.new }
+    let(:message) { Pling::Message.new }
+    let(:gateway) { mock(:deliver => true) }
+
+    it 'should try to discover a gateway' do
+      Pling::Gateway.should_receive(:discover).with(device).and_return(gateway)
+      subject.deliver(message, device)
+    end
+
+    it 'should try to deliver to the discoveredgateway' do
+      gateway.should_receive(:deliver).with(message, device)
+      Pling::Gateway.stub(:discover).and_return(gateway)
+      subject.deliver(message, device)
+    end
+  end
+end

data/spec/pling/delayed_initializer_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Pling::DelayedInitializer do
+
+  it { should be_kind_of Array }
+  it { should be_empty }
+
+  describe '#initialize!' do
+    it 'should initialize all stored arrays' do
+      subject << [String, "new string"]
+      subject << [String, "other string"]
+      subject.initialize!
+      subject.should == ["new string", "other string"]
+    end
+
+    it 'should not change other object instances' do
+      object = Object.new
+      subject << object
+      subject.initialize!
+      subject.first.should be === object
+    end
+  end
+
+  describe '#use' do
+    it 'should add the arguments as an item to the array' do
+      subject.use String, "new string"
+      subject.should eq([[String, "new string"]])
+    end
+  end
+
+end

data/spec/pling/device_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Pling::Device do
+
+  context 'when created with no arguments' do
+    it 'should not require an argument' do
+      expect { Pling::Device.new }.to_not raise_error ArgumentError
+    end
+
+    specify { Pling::Device.new.should_not be_valid }
+  end
+
+  context 'when created with an empty hash' do
+    it 'should accept a hash of attributes' do
+      expect { Pling::Device.new({}) }.to_not raise_error
+    end
+
+    specify { Pling::Device.new({}).should_not be_valid }
+  end
+
+  context 'when created with an hash of valid attributes' do
+    subject { Pling::Device.new(:identifier => 'XXXX', :type => 'android') }
+
+    its(:identifier) { should eq('XXXX') }
+    its(:type) { should eq(:android) }
+
+    it { should be_valid }
+  end
+
+  context 'when created with an hash of invalid attributes' do
+    it 'should ignore the invalid paramters' do
+      expect { Pling::Device.new({ :random_param => true }) }.to_not raise_error
+    end
+  end
+
+  describe '#to_pling_device' do
+    it 'should return self' do
+      subject.to_pling_device.should be === subject
+    end
+  end
+
+  describe '#identifier=' do
+    it 'should call #to_s on the given identifier' do
+      subject.identifier = stub(:to_s => 'XXXX')
+      subject.identifier.should eq('XXXX')
+    end
+  end
+
+  describe '#type=' do
+    it 'should call #to_sym on the given type' do
+      subject.type = 'android'
+      subject.type.should eq(:android)
+    end
+  end
+
+  it { should respond_to :deliver }
+
+  describe '#deliver' do
+    subject { Pling::Device.new(:identifier => 'XXXX', :type => 'android') }
+
+    let(:message) { Pling::Message.new }
+    let(:gateway) { stub(:deliver => true) }
+
+    before { Pling::Gateway.stub(:discover => gateway) }
+
+    it 'should require a message as parameter' do
+      expect { subject.deliver }.to raise_error ArgumentError
+    end
+
+    it 'should deliver the given message to an gateway' do
+      gateway.should_receive(:deliver).with(message, subject)
+      subject.deliver(message)
+    end
+  end
+end