pusher 0.17.0 → 2.0.3

data/lib/pusher/client.rb

@@ -1,55 +1,80 @@
+require 'base64'
 require 'pusher-signature'
 
 module Pusher
   class Client
-    attr_accessor :scheme, :host, :port, :app_id, :key, :secret
+    attr_accessor :scheme, :host, :port, :app_id, :key, :secret, :encryption_master_key
     attr_reader :http_proxy, :proxy
     attr_writer :connect_timeout, :send_timeout, :receive_timeout,
                 :keep_alive_timeout
 
     ## CONFIGURATION ##
+    DEFAULT_CONNECT_TIMEOUT = 5
+    DEFAULT_SEND_TIMEOUT = 5
+    DEFAULT_RECEIVE_TIMEOUT = 5
+    DEFAULT_KEEP_ALIVE_TIMEOUT = 30
+    DEFAULT_CLUSTER = "mt1"
+
+    # Loads the configuration from an url in the environment
+    def self.from_env(key = 'PUSHER_URL')
+      url = ENV[key] || raise(ConfigurationError, key)
+      from_url(url)
+    end
+
+    # Loads the configuration from a url
+    def self.from_url(url)
+      client = new
+      client.url = url
+      client
+    end
 
     def initialize(options = {})
-      default_options = {
-        :scheme => 'http',
-        :port => 80,
-      }
-      merged_options = default_options.merge(options)
+      @scheme = "https"
+      @port = options[:port] || 443
 
-      if options.has_key?(:host)
-        merged_options[:host] = options[:host]
-      elsif options.has_key?(:cluster)
-        merged_options[:host] = "api-#{options[:cluster]}.pusher.com"
-      else
-        merged_options[:host] = "api.pusherapp.com"
+      if options.key?(:encrypted)
+        warn "[DEPRECATION] `encrypted` is deprecated and will be removed in the next major version. Use `use_tls` instead."
       end
 
-      @scheme, @host, @port, @app_id, @key, @secret = merged_options.values_at(
-        :scheme, :host, :port, :app_id, :key, :secret
-      )
+      if options[:use_tls] == false || options[:encrypted] == false
+        @scheme = "http"
+        @port = options[:port] || 80
+      end
 
-      @http_proxy = nil
-      self.http_proxy = options[:http_proxy] if options[:http_proxy]
+      @app_id = options[:app_id]
+      @key = options[:key]
+      @secret = options[:secret]
+
+      @host = options[:host]
+      @host ||= "api-#{options[:cluster]}.pusher.com" unless options[:cluster].nil? || options[:cluster].empty?
+      @host ||= "api-#{DEFAULT_CLUSTER}.pusher.com"
+
+      @encryption_master_key = Base64.strict_decode64(options[:encryption_master_key_base64]) if options[:encryption_master_key_base64]
+
+      @http_proxy = options[:http_proxy]
 
       # Default timeouts
-      @connect_timeout = 5
-      @send_timeout = 5
-      @receive_timeout = 5
-      @keep_alive_timeout = 30
+      @connect_timeout = DEFAULT_CONNECT_TIMEOUT
+      @send_timeout = DEFAULT_SEND_TIMEOUT
+      @receive_timeout = DEFAULT_RECEIVE_TIMEOUT
+      @keep_alive_timeout = DEFAULT_KEEP_ALIVE_TIMEOUT
     end
 
     # @private Returns the authentication token for the client
     def authentication_token
+      raise ConfigurationError, :key unless @key
+      raise ConfigurationError, :secret unless @secret
       Pusher::Signature::Token.new(@key, @secret)
     end
 
     # @private Builds a url for this app, optionally appending a path
     def url(path = nil)
+      raise ConfigurationError, :app_id unless @app_id
       URI::Generic.build({
-        :scheme => @scheme,
-        :host => @host,
-        :port => @port,
-        :path => "/apps/#{@app_id}#{path}"
+        scheme: @scheme,
+        host: @host,
+        port: @port,
+        path: "/apps/#{@app_id}#{path}"
       })
     end
 
@@ -73,13 +98,12 @@ module Pusher
       @http_proxy = http_proxy
       uri = URI.parse(http_proxy)
       @proxy = {
-        :scheme => uri.scheme,
-        :host => uri.host,
-        :port => uri.port,
-        :user => uri.user,
-        :password => uri.password
+        scheme: uri.scheme,
+        host: uri.host,
+        port: uri.port,
+        user: uri.user,
+        password: uri.password
       }
-      @http_proxy
     end
 
     # Configure whether Pusher API calls should be made over SSL
@@ -99,6 +123,8 @@ module Pusher
     end
 
     def cluster=(cluster)
+      cluster = DEFAULT_CLUSTER if cluster.nil? || cluster.empty?
+
       @host = "api-#{cluster}.pusher.com"
     end
 
@@ -108,7 +134,13 @@ module Pusher
       @connect_timeout, @send_timeout, @receive_timeout = value, value, value
     end
 
-    ## INTERACE WITH THE API ##
+    # Set an encryption_master_key to use with private-encrypted channels from
+    # a base64 encoded string.
+    def encryption_master_key_base64=(s)
+      @encryption_master_key = s ? Base64.strict_decode64(s) : nil
+    end
+
+    ## INTERACT WITH THE API ##
 
     def resource(path)
       Resource.new(self, path)
@@ -133,7 +165,7 @@ module Pusher
     # @raise [Pusher::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
     #
     def get(path, params = {})
-      Resource.new(self, path).get(params)
+      resource(path).get(params)
     end
 
     # GET arbitrary REST API resource using an asynchronous http client.
@@ -149,20 +181,20 @@ module Pusher
     # @return Either an EM::DefaultDeferrable or a HTTPClient::Connection
     #
     def get_async(path, params = {})
-      Resource.new(self, path).get_async(params)
+      resource(path).get_async(params)
     end
 
     # POST arbitrary REST API resource using a synchronous http client.
     # Works identially to get method, but posts params as JSON in post body.
     def post(path, params = {})
-      Resource.new(self, path).post(params)
+      resource(path).post(params)
     end
 
     # POST arbitrary REST API resource using an asynchronous http client.
     # Works identially to get_async method, but posts params as JSON in post
     # body.
     def post_async(path, params = {})
-      Resource.new(self, path).post_async(params)
+      resource(path).post_async(params)
     end
 
     ## HELPER METHODS ##
@@ -176,18 +208,18 @@ module Pusher
       WebHook.new(request, self)
     end
 
-    # Return a convenience channel object by name. No API request is made.
+    # Return a convenience channel object by name that delegates operations
+    # on a channel. No API request is made.
     #
     # @example
     #   Pusher['my-channel']
     # @return [Channel]
-    # @raise [ConfigurationError] unless key, secret and app_id have been
-    #   configured. Channel names should be less than 200 characters, and
+    # @raise [Pusher::Error] if the channel name is invalid.
+    #   Channel names should be less than 200 characters, and
     #   should not contain anything other than letters, numbers, or the
     #   characters "_\-=@,.;"
     def channel(channel_name)
-      raise ConfigurationError, 'Missing client configuration: please check that key, secret and app_id are configured.' unless configured?
-      Channel.new(url, channel_name, self)
+      Channel.new(nil, channel_name, self)
     end
 
     alias :[] :channel
@@ -223,7 +255,7 @@ module Pusher
       get("/channels/#{channel_name}", params)
     end
 
-    # Request info for users of a channel
+    # Request info for users of a presence channel
     #
     # GET /apps/[id]/channels/[channel_name]/users
     #
@@ -258,6 +290,21 @@ module Pusher
       post('/events', trigger_params(channels, event_name, data, params))
     end
 
+    # Trigger multiple events at the same time
+    #
+    # POST /apps/[app_id]/batch_events
+    #
+    # @param events [Array] List of events to publish
+    #
+    # @return [Hash] See Pusher API docs
+    #
+    # @raise [Pusher::Error] Unsuccessful response - see the error message
+    # @raise [Pusher::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
+    #
+    def trigger_batch(*events)
+      post('/batch_events', trigger_batch_params(events.flatten))
+    end
+
     # Trigger an event on one or more channels asynchronously.
     # For parameters see #trigger
     #
@@ -265,6 +312,14 @@ module Pusher
       post_async('/events', trigger_params(channels, event_name, data, params))
     end
 
+    # Trigger multiple events asynchronously.
+    # For parameters see #trigger_batch
+    #
+    def trigger_batch_async(*events)
+      post_async('/batch_events', trigger_batch_params(events.flatten))
+    end
+
+
     # Generate the expected response for an authentication endpoint.
     # See http://pusher.com/docs/authenticating_users for details.
     #
@@ -285,18 +340,26 @@ module Pusher
     #
     # @return [Hash]
     #
+    # @raise [Pusher::Error] if channel_name or socket_id are invalid
+    #
     # @private Custom data is sent to server as JSON-encoded string
     #
     def authenticate(channel_name, socket_id, custom_data = nil)
       channel_instance = channel(channel_name)
-      channel_instance.authenticate(socket_id, custom_data)
+      r = channel_instance.authenticate(socket_id, custom_data)
+      if channel_name.match(/^private-encrypted-/)
+        r[:shared_secret] = Base64.strict_encode64(
+          channel_instance.shared_secret(encryption_master_key)
+        )
+      end
+      r
     end
 
     # @private Construct a net/http http client
     def sync_http_client
-      @client ||= begin
-        require 'httpclient'
+      require 'httpclient'
 
+      @client ||= begin
         HTTPClient.new(@http_proxy).tap do |c|
           c.connect_timeout = @connect_timeout
           c.send_timeout = @send_timeout
@@ -315,14 +378,14 @@ module Pusher
         require 'em-http' unless defined?(EventMachine::HttpRequest)
 
         connection_opts = {
-          :connect_timeout => @connect_timeout,
-          :inactivity_timeout => @receive_timeout,
+          connect_timeout: @connect_timeout,
+          inactivity_timeout: @receive_timeout,
         }
 
         if defined?(@proxy)
           proxy_opts = {
-            :host => @proxy[:host],
-            :port => @proxy[:port]
+            host: @proxy[:host],
+            port: @proxy[:port]
           }
           if @proxy[:user]
             proxy_opts[:authorization] = [@proxy[:user], @proxy[:password]]
@@ -338,29 +401,73 @@ module Pusher
 
     def trigger_params(channels, event_name, data, params)
       channels = Array(channels).map(&:to_s)
-      raise Pusher::Error, "Too many channels (#{channels.length}), max 10" if channels.length > 10
+      raise Pusher::Error, "Too many channels (#{channels.length}), max 100" if channels.length > 100
 
-      encoded_data = case data
-      when String
-        data
+      encoded_data = if channels.any?{ |c| c.match(/^private-encrypted-/) } then
+        raise Pusher::Error, "Cannot trigger to multiple channels if any are encrypted" if channels.length > 1
+        encrypt(channels[0], encode_data(data))
       else
-        begin
-          MultiJson.encode(data)
-        rescue MultiJson::DecodeError => e
-          Pusher.logger.error("Could not convert #{data.inspect} into JSON")
-          raise e
-        end
+        encode_data(data)
       end
 
-      return params.merge({
-        :name => event_name,
-        :channels => channels,
-        :data => encoded_data,
+      params.merge({
+        name: event_name,
+        channels: channels,
+        data: encoded_data,
+      })
+    end
+
+    def trigger_batch_params(events)
+      {
+        batch: events.map do |event|
+          event.dup.tap do |e|
+            e[:data] = if e[:channel].match(/^private-encrypted-/) then
+              encrypt(e[:channel], encode_data(e[:data]))
+            else
+              encode_data(e[:data])
+            end
+          end
+        end
+      }
+    end
+
+    # JSON-encode the data if it's not a string
+    def encode_data(data)
+      return data if data.is_a? String
+      MultiJson.encode(data)
+    end
+
+    # Encrypts a message with a key derived from the master key and channel
+    # name
+    def encrypt(channel_name, encoded_data)
+      raise ConfigurationError, :encryption_master_key unless @encryption_master_key
+
+      # Only now load rbnacl, so that people that aren't using it don't need to
+      # install libsodium
+      require_rbnacl
+
+      secret_box = RbNaCl::SecretBox.new(
+        channel(channel_name).shared_secret(@encryption_master_key)
+      )
+
+      nonce = RbNaCl::Random.random_bytes(secret_box.nonce_bytes)
+      ciphertext = secret_box.encrypt(nonce, encoded_data)
+
+      MultiJson.encode({
+        "nonce" => Base64::strict_encode64(nonce),
+        "ciphertext" => Base64::strict_encode64(ciphertext),
       })
     end
 
     def configured?
       host && scheme && key && secret && app_id
     end
+
+    def require_rbnacl
+      require 'rbnacl'
+    rescue LoadError => e
+      $stderr.puts "You don't have rbnacl installed in your application. Please add it to your Gemfile and run bundle install"
+      raise e
+    end
   end
 end

data/lib/pusher/request.rb

@@ -8,7 +8,9 @@ module Pusher
 
     def initialize(client, verb, uri, params, body = nil)
       @client, @verb, @uri = client, verb, uri
-      @head = {}
+      @head = {
+        'X-Pusher-Library' => 'pusher-http-ruby ' + Pusher::VERSION
+      }
 
       @body = body
       if body
@@ -83,7 +85,7 @@ module Pusher
       when 200
         return symbolize_first_level(MultiJson.decode(body))
       when 202
-        return true
+        return body.empty? ? true : symbolize_first_level(MultiJson.decode(body))
       when 400
         raise Error, "Bad request: #{body}"
       when 401
@@ -92,6 +94,8 @@ module Pusher
         raise Error, "404 Not found (#{@uri.path})"
       when 407
         raise Error, "Proxy Authentication Required"
+      when 413
+        raise Error, "Payload Too Large > 10KB"
       else
         raise Error, "Unknown error (status code #{status_code}): #{body}"
       end

data/lib/pusher/version.rb

@@ -0,0 +1,3 @@
+module Pusher
+  VERSION = '2.0.3'
+end

data/lib/pusher/webhook.rb

@@ -30,8 +30,8 @@ module Pusher
     #
     def initialize(request, client = Pusher)
       @client = client
-      # Should work without Rack
-      if defined?(Rack::Request) && request.kind_of?(Rack::Request)
+      # For Rack::Request and ActionDispatch::Request
+      if request.respond_to?(:env) && request.respond_to?(:content_type)
         @key = request.env['HTTP_X_PUSHER_KEY']
         @signature = request.env["HTTP_X_PUSHER_SIGNATURE"]
         @content_type = request.content_type

data/lib/pusher.rb

@@ -17,22 +17,30 @@ module Pusher
   #   end
   class Error < RuntimeError; end
   class AuthenticationError < Error; end
-  class ConfigurationError < Error; end
+  class ConfigurationError < Error
+    def initialize(key)
+      super "missing key `#{key}' in the client configuration"
+    end
+  end
   class HTTPError < Error; attr_accessor :original_error; end
 
   class << self
     extend Forwardable
 
-    def_delegators :default_client, :scheme, :host, :port, :app_id, :key, :secret, :http_proxy
-    def_delegators :default_client, :scheme=, :host=, :port=, :app_id=, :key=, :secret=, :http_proxy=
+    def_delegators :default_client, :scheme, :host, :port, :app_id, :key,
+                   :secret, :http_proxy, :encryption_master_key_base64
+    def_delegators :default_client, :scheme=, :host=, :port=, :app_id=, :key=,
+                   :secret=, :http_proxy=, :encryption_master_key_base64=
 
-    def_delegators :default_client, :authentication_token, :url
+    def_delegators :default_client, :authentication_token, :url, :cluster
     def_delegators :default_client, :encrypted=, :url=, :cluster=
     def_delegators :default_client, :timeout=, :connect_timeout=, :send_timeout=, :receive_timeout=, :keep_alive_timeout=
 
     def_delegators :default_client, :get, :get_async, :post, :post_async
-    def_delegators :default_client, :channels, :channel_info, :channel_users, :trigger, :trigger_async
+    def_delegators :default_client, :channels, :channel_info, :channel_users
+    def_delegators :default_client, :trigger, :trigger_batch, :trigger_async, :trigger_batch_async
     def_delegators :default_client, :authenticate, :webhook, :channel, :[]
+    def_delegators :default_client, :notify
 
     attr_writer :logger
 
@@ -45,15 +53,15 @@ module Pusher
     end
 
     def default_client
-      @default_client ||= Pusher::Client.new
+      @default_client ||= begin
+        cli = Pusher::Client
+        ENV['PUSHER_URL'] ? cli.from_env : cli.new
+      end
     end
   end
-
-  if ENV['PUSHER_URL']
-    self.url = ENV['PUSHER_URL']
-  end
 end
 
+require 'pusher/version'
 require 'pusher/channel'
 require 'pusher/request'
 require 'pusher/resource'