viaduct-webpush 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bd894fea39bb8ad5d5f82a3fbf241fa44f2d1b7
-  data.tar.gz: 3cd260918918a5f47716bdf2fce2a0e7bcbfd26b
+  metadata.gz: 79f4047fad65b0886d126655ce6ed34a0570028f
+  data.tar.gz: e375862818d3424875da28e003686396902de8c3
 SHA512:
-  metadata.gz: 305429ca69ea43580da39e84854414c1bdeae1d212f6d6933d696b15de29913b02b89584bd7822ec565d0900e8bf49b5982cf33e8e72402706e19bc90d676245
-  data.tar.gz: 10d37a1a0e1743474b9dcc06d38e19cd4ec2a37d22fb20607c1d644f529578bba3d5ce03b057da3c73356af1e11cba600843921415487555efd54ad08fd55c21
+  metadata.gz: 6e0ed7ae59ed0895f75c92f1ec7c97a8c0d1ab404acc215ad042358ed7f3bc48a2a652af3148b814b2a7fb272928621a8fab3ae0e18612301975aaea2b961f1c
+  data.tar.gz: be83004eff45e0b50a89b6b696093c8c982051371ba8425872edef4ded2924fcb2d1c5571e817fecb8be11add2a8d5d0abc4a463970019d5f4eb5da82e912bb0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -14,12 +14,24 @@ gem 'viaduct-webpush', :require => 'viaduct/webpush'
 
 ## Usage
 
+### Configuration
+
 ```ruby
 require 'viaduct/webpush'
 
 Viaduct::WebPush.token = 'your-token'
 Viaduct::WebPush.secret = 'your-secret'
 
+# Additional configuration for websockets
+require 'viaduct/webpush/websocket'
+Viaduct::WebPush::WebSocket.logger = Your.logger # optional
+```
+
+### Sending Messages via the HTTP API
+
+Sending messages via the HTTP API is ideal if you're sending low-frequency messages and when you don't need to receive any messages in return.
+
+```ruby
 # Sending a single message
 Viaduct::WebPush['test-channel'].trigger('say-hello', {
   :name => 'Adam'
@@ -33,3 +45,51 @@ Viaduct::WebPush::Channel.multi_trigger(['channel1', 'channel2'], 'say-hello', {
 # Generating a signature for private channels
 Viaduct::WebPush::Channel.generate_signature(session_id, channel_name)
 ```
+
+### Sending and Receiving via the Websockets API
+
+If you want to receive data from Viaduct WebPush, or you plan on sending messages very frequently, you'll want to use the websockets API.
+
+```ruby
+# Ensure you've included the websockets classes
+require 'viaduct/webpush/websocket'
+
+# Connect to the VWP service
+connection = Viaduct::WebPush::WebSocket.connection
+
+# Subscribe to any channels you want to send/recieve on
+channel1 = connection.subscribe('channel1')
+
+# Bind a handler to a specific event that comes in on a channel
+channel1.bind 'say-hello' do |received_data|
+  puts received_data # deserialized JSON
+end
+
+# Send messages out on a channel
+channel1.trigger('say-hello', {
+  :name => "Adam"
+})
+
+# Disconnect from VWP when you're done
+connection.disconnect
+
+# Reconnect if you need to later
+connection.connect
+```
+
+You can also choose not authenticate if you only want to receive messages, or not to automatically connect if you want to set up all of your bindings before connecting.
+
+```ruby
+# Do not authenticate, gives you a receive-only connection
+connection = Viaduct::WebPush::WebSocket.connection(:authenticate => false)
+
+# Do not automatically connect, set up your bindings first
+connection = Viaduct::WebPush::WebSocket.connection(:autoconnect => false)
+
+channel1 = connection.subscribe('channel1')
+channel1.bind 'say-hello' do |received_data|
+  puts received_data
+end
+
+connection.connect
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/viaduct/web_push/channel.rb

@@ -1,9 +1,23 @@
+# Class for sending messages to viaduct via the HTTP API
+
 module Viaduct
   module WebPush
     class Channel
 
-      def initialize(name)
+      attr_accessor :subscribed, :name, :bindings
+
+      def initialize(name, connection)
         @name = name
+        @connection = connection
+        @bindings = Hash.new([])
+        @subscribed = false
+      end
+
+      #
+      # Blank name indicates global channel
+      #
+      def global?
+        @name.nil?
       end
 
       #
@@ -22,6 +36,31 @@ module Viaduct
         end
       end
 
+      #
+      # Bind some code to an incoming message on this channel
+      #
+      def bind(event, &block)
+        @bindings[event] += [block]
+      end
+
+      #
+      # Run the bindings for an event
+      #
+      def dispatch(event, data)
+        @bindings[event].each do |binding|
+          binding.call(data)
+        end
+      end
+
+      #
+      # Send request subscription for this channel from VWP
+      #
+      def register
+        return if @subscibed || global?
+        signature = self.class.generate_signature(@connection.session_id, @name)
+        @connection.register_subscription(@name, signature)
+      end
+
       #
       # Trigger a single even on a given channel
       #
@@ -29,7 +68,6 @@ module Viaduct
         WebPush.request('trigger', {:channel => channel, :event => event, :data => data.to_json})
       end
 
-
       #
       # Trigger an event on multiple channels simultaneously
       #

data/lib/viaduct/web_push/web_socket/channel.rb

@@ -0,0 +1,80 @@
+module Viaduct
+  module WebPush
+    module WebSocket
+      class Channel
+
+        attr_accessor :subscribed, :name, :bindings
+
+        def initialize(name, connection)
+          @name = name 
+          @connection = connection
+          @bindings = Hash.new([])
+          @subscribed = false
+        end
+
+        #
+        # Blank name indicates global channel
+        # 
+        def global?
+          @name.nil?
+        end
+
+        #
+        # Bind some code to an incoming message on this channel
+        # 
+        def bind(event, &block)
+          @bindings[event] += [block]
+        end
+
+        #
+        # Run the bindings for an event
+        # 
+        def dispatch(event, data)
+          @bindings[event].each do |binding|
+            binding.call(data)
+          end
+        end
+
+        #
+        # Send request subscription for this channel from VWP
+        # 
+        def register
+          return if @subscibed || global?
+
+          if @name =~ /^private-/
+            signature = self.class.generate_signature(@connection.session_id, @name)
+          else
+            signature = nil
+          end
+          
+          @connection.register_subscription(@name, signature)
+        end
+
+        #
+        # Trigger an event on this channel
+        #
+        def trigger(event, data = {})
+          @connection.trigger(@name, event, data)
+        end
+
+        def inspect
+          String.new.tap do |s|
+            s << "#<#{self.class.name}:#{self.object_id} "
+            s << [:name, :subscribed].map do |attrib|
+              "#{attrib}: #{self.send(attrib).inspect}"
+            end.join(', ')
+            s << ">"
+          end
+        end
+
+        #
+        # Generate a HMAC signature for private channels
+        #
+        def self.generate_signature(session_id, channel)
+          OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, WebPush.secret, "#{session_id}:#{channel}")
+        end
+        
+      end
+    end
+  end
+end

data/lib/viaduct/web_push/web_socket/connection.rb

@@ -0,0 +1,190 @@
+module Viaduct
+  module WebPush
+    module WebSocket
+      class Connection
+
+        attr_reader :connected, :session_id, :channels, :authenticated
+
+        DEFAULT_OPTIONS = {
+          :authenticate => true,
+          :autoconnect => true
+        }
+
+        def initialize(options={})
+          @options = DEFAULT_OPTIONS.merge(options)
+
+          @connected = false
+          @authenticated = false
+          @session_id = nil
+          @channels = {}
+          @logger = WebSocket.logger
+
+          # Set up global vwp events
+          @global_channel = subscribe(nil)
+
+          # On connect, store data from the payload, send vwp:subscribe events
+          # for each channel that's already been addded
+          @global_channel.bind 'vwp:connected' do |data|
+            @logger.info "Connected to vwp"
+
+            @global_channel.subscribed = true
+            @session_id = data["session_id"]
+            @connected = true
+
+            register_subscriptions
+          end
+
+          # If we're sending messages we need to authenticate after we've connected to vwp
+          if @options[:authenticate]
+            @global_channel.bind 'vwp:connected' do
+              authenticate
+            end
+            @global_channel.bind 'vwp:authenticated' do 
+              @logger.info "Authenticated with vwp"
+              @authenticated = true
+            end
+          end
+
+          # When we've successfully subscribed to a channel set the subscribed bit to true on the channel
+          @global_channel.bind 'vwp:subscribed' do |data|
+            channel_id = data['channel']
+            @channels[channel_id].subscribed = true
+            @logger.info "Subscribed to vwp #{data['channel_name']}"
+          end
+
+          connect if @options[:autoconnect]
+        end
+
+        def [](channel_name)
+          @channels[channel_name]
+        end
+
+        #
+        # Create a new channel object and send a vwp:subscribe event if we're
+        # already connected to vwp
+        # 
+        def subscribe(channel_name)
+          @channels[channel_name] ||= Channel.new(channel_name, self)
+          @channels[channel_name].register if @connected 
+          @channels[channel_name]
+        end
+
+        #
+        # Create a new thread and connect to vwp in it.
+        # Create an event loop for the thread which will dispatch incoming messages
+        # 
+        def connect
+          return if @websocket
+          @logger.debug "Connecting..."
+
+          Thread.abort_on_exception = true
+          @websocket_thread = Thread.new do
+            @websocket = RawSocket.new
+            loop do
+              @websocket.receive.each do |message|
+                data = JSON.parse(message)
+                @logger.debug data
+                dispatch(data)
+              end
+            end
+          end
+
+          self
+        end
+
+        #
+        # Disconnect the websocket server and reset all variables, set all channels
+        # as unsubscribed
+        # 
+        def disconnect
+          @websocket.disconnect
+          @websocket = nil
+          @websocket_thread.kill
+          @websocket_thread = nil
+          @connected = false
+          @session_id = nil
+          @channels.each {|name, chan| chan.subscribed = false }
+          @logger.info "Disconnected from vwp"
+        end
+
+        #
+        # Build a vwp message and send it via the websocket
+        # 
+        def trigger(channel_name, event, data)
+          return false unless @authenticated
+
+          payload = JSON.generate({
+            "event" => "vwp:send",
+            "data" => {
+              "channel" => channel_name,
+              "event" => event,
+              "data" => data
+            }
+          })
+
+          @websocket.send_data(payload)
+          true
+        end
+
+        #
+        # Send a vwp:subscribe message via the websocket. The socket name and signature
+        # are calculated by the Channel
+        #
+        def register_subscription(channel_name, signature)
+          payload = JSON.generate({"event" => "vwp:subscribe", "data" => {
+            "channel" => channel_name,
+            "signature" => signature
+          }})
+          @websocket.send_data(payload)
+        end
+
+        def inspect
+          String.new.tap do |s|
+            s << "#<#{self.class.name}:#{self.object_id} "
+            s << [:connected, :session_id, :channels].map do |attrib|
+              "#{attrib}: #{self.send(attrib).inspect}"
+            end.join(', ')
+            s << ">"
+          end
+        end
+
+        protected
+
+        #
+        # Process some payload data and dispatch the message to the relevant
+        # channel. The channel will then dispatch the data to the correct binding.
+        # 
+        def dispatch(payload_data)
+          event = payload_data['event']
+          channel = payload_data['channel']
+          data = payload_data['data']
+
+          if @channels[channel]
+            @channels[channel].dispatch(event, data)
+          end
+        end
+
+        # Send a vwp:subscribe message for every channel
+        def register_subscriptions
+          @channels.each do |name, chan|
+            chan.register
+          end
+        end
+
+        #
+        # Send a vwp:authenticate message that we need if we're going to be sending data
+        # on the websocket.
+        # 
+        def authenticate
+          @logger.debug "Authenticating..."
+
+          payload = JSON.generate({"event" => "vwp:authenticate", "data" => {
+            "secret" => Viaduct::WebPush.secret
+          }})
+          @websocket.send_data(payload)
+        end
+
+      end
+    end
+  end
+end

data/lib/viaduct/web_push/web_socket/raw_socket.rb

@@ -0,0 +1,77 @@
+module Viaduct
+  module WebPush
+    module WebSocket
+      class RawSocket
+
+        WAIT_EXCEPTIONS  = [Errno::EWOULDBLOCK, Errno::EAGAIN, IO::WaitReadable]
+
+        #
+        # Open an SSL connection and perform the HTTP upgrade/websockets handhsake procedure
+        # 
+        def initialize
+          @handshake = ::WebSocket::Handshake::Client.new(:url => Viaduct::WebPush::WebSocket.endpoint)
+          @connection = TCPSocket.new(@handshake.host, @handshake.port || 443)
+
+          ssl_ctx = OpenSSL::SSL::SSLContext.new
+          ssl_ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          ssl_ctx.cert_store = OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE
+
+          ssl = OpenSSL::SSL::SSLSocket.new(@connection, ssl_ctx)
+          ssl.sync_close = true
+          ssl.connect
+
+          @connection = ssl
+
+          @connection.write @handshake.to_s
+          @connection.flush
+
+          while line = @connection.gets
+            @handshake << line
+            break if @handshake.finished?
+          end
+
+          raise HandshakeError unless @handshake.valid?
+        end
+
+        #
+        # Send a websocket frame out on the connection
+        # 
+        def send_data(message, type=:text)
+          frame = ::WebSocket::Frame::Outgoing::Client.new(:version => @handshake.version, :data => message, :type => type)
+          @connection.write frame.to_s
+          @connection.flush
+        end
+
+        #
+        # Read data from the socket and wait with IO#select
+        # 
+        def receive
+          frame = ::WebSocket::Frame::Incoming::Server.new(:version => @handshake.version)
+
+          begin
+            data = @connection.read_nonblock(1024)
+          rescue *WAIT_EXCEPTIONS
+            IO.select([@connection])
+            retry
+          end
+          frame << data
+
+          messages = []
+          while message = frame.next
+            messages << message.to_s
+          end
+
+          messages
+        end
+
+        #
+        # Close the connection
+        # 
+        def disconnect
+          @connection.close
+        end
+      end
+
+    end
+  end
+end

data/lib/viaduct/web_push/web_socket.rb

@@ -0,0 +1,40 @@
+require 'logger'
+require 'websocket'
+require 'viaduct/web_push/web_socket/raw_socket'
+require 'viaduct/web_push/web_socket/connection'
+require 'viaduct/web_push/web_socket/channel'
+
+module Viaduct
+  module WebPush
+    module WebSocket
+
+      class HandshakeError < StandardError; end
+
+      class << self
+
+        attr_writer :logger
+        attr_writer :endpoint
+
+        #
+        # Initialize a websocket connection for sending and receiving messages
+        # 
+        def connection(options={})
+          @connection ||= Connection.new(options)
+        end
+
+        #
+        # Return the endpoint for the websocket server
+        # 
+        def endpoint
+          @endpoint ||= "wss://#{Viaduct::WebPush.webpush_host}/vwp/socket/#{Viaduct::WebPush.token}"
+        end 
+
+
+        def logger
+          @logger ||= Logger.new(STDOUT)
+        end
+      
+      end
+    end
+  end
+end

data/lib/viaduct/web_push.rb

@@ -10,11 +10,18 @@ module Viaduct
 
     class << self
 
+      #
+      # Return the host for the VWP service
+      # 
+      def webpush_host
+        @webpush_host ||= 'webpush.viaduct.io'
+      end
+
       #
       # Return the endpoint for API request
       #
       def endpoint
-        @endpoint ||= 'https://webpush.viaduct.io/vwp/api'
+        @endpoint ||= "https://#{self.webpush_host}/vwp/api"
       end
 
       #
@@ -34,6 +41,7 @@ module Viaduct
       #
       # Allow some configuration to be overridden/set
       #
+      attr_writer :webpush_host
       attr_writer :endpoint
       attr_writer :token
       attr_writer :secret
@@ -46,6 +54,7 @@ module Viaduct
         @channels[name] ||= Channel.new(name)
       end
 
+
       #
       # Make an HTTP request to the WebPush API
       #

data/lib/viaduct/webpush/websocket.rb

@@ -0,0 +1 @@
+require 'viaduct/web_push/web_socket'

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: viaduct-webpush
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2015-01-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -30,6 +58,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: A client library allows messages to be sent to the WebPush API.
 email:
 - adam@viaduct.io
@@ -37,10 +79,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
 - README.md
+- Rakefile
 - lib/viaduct/web_push.rb
 - lib/viaduct/web_push/channel.rb
+- lib/viaduct/web_push/web_socket.rb
+- lib/viaduct/web_push/web_socket/channel.rb
+- lib/viaduct/web_push/web_socket/connection.rb
+- lib/viaduct/web_push/web_socket/raw_socket.rb
 - lib/viaduct/webpush.rb
+- lib/viaduct/webpush/websocket.rb
 homepage: http://viaduct.io
 licenses:
 - MIT
@@ -66,4 +115,3 @@ signing_key:
 specification_version: 4
 summary: A client library for the Viaduct WebPush API.
 test_files: []
-has_rdoc: