pubnub 0.1.12 → 3.3.0.1

data/lib/pubnub.rb

@@ -2,291 +2,354 @@
 ## http://www.pubnub.com/blog/ruby-push-api - Ruby Push API Blog
 
 ## PubNub Real Time Push APIs and Notifications Framework
-## Copyright (c) 2010 Stephen Blum
+## Copyright (c) 2012 PubNub
 ## http://www.pubnub.com/
 
 ## -----------------------------------
-## PubNub 3.1 Real-time Push Cloud API
+## PubNub 3.3 Real-time Push Cloud API
 ## -----------------------------------
 
-## including required libraries
-require 'openssl'
 require 'base64'
 require 'open-uri'
 require 'uri'
-require 'net/http'
-require 'net/https'
-require 'json'
-require 'pp'
-require 'rubygems'
-require 'securerandom'
-require 'digest'
+
 require 'pubnub_crypto'
+require 'pubnub_request'
+require 'pubnub_deferrable'
+
+require 'eventmachine'
+require 'uuid'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+
 
 class Pubnub
-  MAX_RETRIES = 3
-  retries=0
-  #**
-  #* Pubnub 3.1 with Cipher Key
-  #*
-  #* Init the Pubnub Client API
-  #*
-  #* @param string publish_key required key to send messages.
-  #* @param string subscribe_key required key to receive messages.
-  #* @param string secret_key required key to sign messages.
-  #* @param string cipher_key required to encrypt messages.
-  #* @param boolean ssl required for 2048 bit encrypted messages.
-  #*
-  def initialize( publish_key, subscribe_key, secret_key, cipher_key, ssl_on )
-    @publish_key   = publish_key
-    @subscribe_key = subscribe_key
-    @secret_key    = secret_key
-    @cipher_key    = cipher_key
-    @ssl           = ssl_on
-    @origin        = 'pubsub.pubnub.com'
-
-    if @ssl
-      @origin = 'https://' + @origin
+
+  class PresenceError < RuntimeError;
+  end
+  class PublishError < RuntimeError;
+  end
+  class SubscribeError < RuntimeError;
+  end
+  class InitError < RuntimeError;
+  end
+
+  attr_accessor :publish_key, :subscribe_key, :secret_key, :cipher_key, :ssl, :channel, :origin, :session_uuid
+
+
+  #ORIGINS = %w(newcloud-virginia.pubnub.com newcloud-california.pubnub.com newcloud-ireland.pubnub.com newcloud-tokyo.pubnub.com)
+  ORIGIN_HOST = 'pubsub.pubnub.com'
+  #ORIGIN_HOST = 'newcloud-california.pubnub.com'
+  #ORIGIN_HOST = 'test.pubnub.com'
+
+  def initialize(*args)
+
+    if args.size == 5 # passing in named parameters
+
+      @publish_key = args[0].to_s
+      @subscribe_key = args[1].to_s
+      @secret_key = args[2].to_s
+      @cipher_key = args[3].to_s
+      @ssl = args[4]
+
+    elsif args.size == 1 && args[0].class == Hash # passing in an options hash
+
+      options_hash = HashWithIndifferentAccess.new(args[0])
+      @publish_key = options_hash[:publish_key].blank? ? nil : options_hash[:publish_key].to_s
+      @subscribe_key = options_hash[:subscribe_key].blank? ? nil : options_hash[:subscribe_key].to_s
+      @secret_key = options_hash[:secret_key].blank? ? nil : options_hash[:secret_key].to_s
+      @cipher_key = options_hash[:cipher_key].blank? ? nil : options_hash[:cipher_key].to_s
+      @ssl = options_hash[:ssl].blank? ? false : true
+
     else
-      @origin = 'http://'  + @origin
+      raise(InitError, "Initialize with either a hash of options, or exactly 5 named parameters.")
     end
+
+    @session_uuid = uuid
+    verify_init
+  end
+
+  def verify_init
+    # publish_key and cipher_key are both optional.
+    raise(InitError, "subscribe_key is a mandatory parameter.") if @subscribe_key.blank?
+  end
+
+
+  def publish(options)
+    options = HashWithIndifferentAccess.new(options)
+    publish_request = PubnubRequest.new(:operation => :publish)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    publish_request.ssl = @ssl
+    publish_request.set_channel(options)
+    publish_request.set_callback(options)
+    publish_request.set_cipher_key(options, self.cipher_key)
+    publish_request.set_message(options, self.cipher_key)
+    publish_request.set_publish_key(options, self.publish_key)
+    publish_request.set_subscribe_key(options, self.subscribe_key)
+    publish_request.set_secret_key(options, self.secret_key)
+
+
+    publish_request.format_url!
+
+    _request(publish_request)
   end
 
-  #**
-  #* Publish
-  #*
-  #* Send a message to a channel.
-  #*
-  #* @param array args with channel and message.
-  #* @return array success information.
-  #*
-  def publish(args)
-    ## Fail if bad input.
-    if !(args['channel'] && args['message'] && args['callback'])
-      puts('Missing Channel or Message or Callback')
-      return false
+  def subscribe(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    operation = options[:operation].nil? ? :subscribe : :presence
+
+    subscribe_request = PubnubRequest.new(:operation => operation, :session_uuid => @session_uuid)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    subscribe_request.ssl = @ssl
+    subscribe_request.set_channel(options)
+    subscribe_request.set_callback(options)
+    subscribe_request.set_cipher_key(options, self.cipher_key) unless subscribe_request.operation == "presence"
+
+    subscribe_request.set_subscribe_key(options, self.subscribe_key)
+
+    format_url_options = options[:override_timetoken].present? ? options[:override_timetoken] : nil
+    subscribe_request.format_url!(format_url_options)
+
+    _request(subscribe_request)
+
+  end
+
+  def presence(options)
+    usage_error = "presence() requires :channel and :callback options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
     end
 
-    ## Capture User Input
-    channel = args['channel']
-    message = args['message']
-    callback = args['callback']
-
-    # Encryption of message
-    if @cipher_key.length > 0
-      pc=PubnubCrypto.new(@cipher_key)
-      if message.is_a? Array
-        message=pc.encryptArray(message)
-      else
-        message=pc.encryptObject(message)
-      end
-    else
-      message = args['message'].to_json();
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
+    end
+
+    subscribe(options.merge(:operation => "presence"))
+
+  end
+
+
+  def here_now(options = nil)
+    usage_error = "here_now() requires :channel and :callback options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
     end
 
-    ## Sign message using HMAC
-    String signature = '0'
-    if @secret_key.length > 0
-      signature = "{@publish_key,@subscribe_key,@secret_key,channel,message}"
-      digest = OpenSSL::Digest.new("sha256")
-      key = [ @secret_key ]
-      hmac = OpenSSL::HMAC.hexdigest(digest, key.pack("H*"), signature)
-      signature = hmac
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
     end
 
-    ## Send Message
-    request = [ 'publish', @publish_key, @subscribe_key, signature, channel, '0', message ]
-    args['request'] = request
-    args['callback'] = callback
-    _request(args)
+    here_now_request = PubnubRequest.new(:operation => :here_now)
+
+    here_now_request.ssl = @ssl
+    here_now_request.set_channel(options)
+    here_now_request.set_callback(options)
+
+    here_now_request.set_subscribe_key(options, self.subscribe_key)
+
+    here_now_request.format_url!
+    _request(here_now_request)
+
   end
 
-  #**
-  #* Subscribe
-  #*
-  #* This is NON-BLOCKING.
-  #* Listen for a message on a channel.
-  #*
-  #* @param array args with channel and message.
-  #* @return false on fail, array on success.
-  #*
-  def subscribe(args)
-    ## Capture User Input
-    channel   = args['channel']
-    callback  = args['callback']
-
-    ## Fail if missing channel
-    if !channel
-      puts "Missing Channel."
-      return false
+  def detailed_history(options = nil)
+    usage_error = "detailed_history() requires :channel, :callback, and :count options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
     end
 
-    ## Fail if missing callback
-    if !callback
-      puts "Missing Callback."
-      return false
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:count] && options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
     end
 
-    ## EventMachine loop
-    #EventMachine.run do
-      timetoken = 0
-      request = [ 'subscribe', @subscribe_key, channel, '0', timetoken.to_s ]
-      args['request'] = request
-      _subscribe(args)
-    #end
+
+    detailed_history_request = PubnubRequest.new(:operation => :detailed_history)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    # /detailed_history/SUBSCRIBE_KEY/CHANNEL/JSONP_CALLBACK/LIMIT
+
+    detailed_history_request.ssl = @ssl
+    detailed_history_request.set_channel(options)
+    detailed_history_request.set_callback(options)
+    detailed_history_request.set_cipher_key(options, self.cipher_key)
+
+    detailed_history_request.set_subscribe_key(options, self.subscribe_key)
+
+    detailed_history_request.history_count = options[:count]
+    detailed_history_request.history_start = options[:start]
+    detailed_history_request.history_end = options[:end]
+    detailed_history_request.history_reverse = options[:reverse]
+
+    detailed_history_request.format_url!
+    _request(detailed_history_request)
+
   end
 
-  #**
-  #* History
-  #*
-  #* Load history from a channel.
-  #*
-  #* @param array args with 'channel' and 'limit'.
-  #* @return mixed false on fail, array on success.
-  #*
-  def history(args)
-    ## Capture User Input
-    limit   = +args['limit'] ? +args['limit'] : 5
-    channel = args['channel']
-    callback = args['callback']
-
-    ## Fail if bad input.
-    if (!channel)
-      puts 'Missing Channel.'
-      return false
+  def history(options = nil)
+    usage_error = "history() requires :channel, :callback, and :limit options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
     end
-    if (!callback)
-      puts 'Missing Callback.'
-      return false
+
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:limit] && options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
     end
 
-    ## Get History
-    request = [ 'history', @subscribe_key, channel, '0', limit.to_s ]
-    args['request'] = request
-    _request(args)
+
+    history_request = PubnubRequest.new(:operation => :history)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    # /history/SUBSCRIBE_KEY/CHANNEL/JSONP_CALLBACK/LIMIT
+
+    history_request.ssl = @ssl
+    history_request.set_channel(options)
+    history_request.set_callback(options)
+    history_request.set_cipher_key(options, self.cipher_key)
+
+    history_request.set_subscribe_key(options, self.subscribe_key)
+    history_request.history_limit = options[:limit]
+
+    history_request.format_url!
+    _request(history_request)
+
   end
 
-  #**
-  #* Time
-  #*
-  #* Timestamp from PubNub Cloud.
-  #*
-  #* @return int timestamp.
-  #*
-  def time(args)
-    request = [ 'time', '0' ]
-    args['request'] = request
-    _request(args)
+  def time(options)
+    options = HashWithIndifferentAccess.new(options)
+    raise(PubNubRuntimeError, "You must supply a callback.") if options['callback'].blank?
+
+    time_request = PubnubRequest.new(:operation => :time)
+    time_request.set_callback(options)
+
+    time_request.format_url!
+    _request(time_request)
+  end
+
+  def my_callback(x, quiet = false)
+    if quiet !=false
+      puts("mycallback says: #{x.to_s}")
+    else
+      ""
+    end
+
   end
 
-  #**
-  #* UUID
-  #*
-  #* Unique identifier generation
-  #*
-  #* @return Unique Identifier
-  #*
-  def UUID()
-    uuid=SecureRandom.base64(32).gsub("/","_").gsub(/=+$/,"")
+  def uuid
+    UUID.new.generate
   end
 
-  private
-
-  #**
-  #* Request URL for subscribe
-  #*
-  #* @param array request of url directories.
-  #* @return array from JSON response.
-  #*
-  def _subscribe(args)
-    channel = args['channel']
-    callback = args['callback']
-    request = args['request']
-
-    # Construct Request
-    url = encode_URL(request);
-    url = @origin + url
-
-    # Execute Request
-    open(url) do |f| 
-      http_response = JSON.parse(f.read)
-      messages = http_response[0]
-      timetoken = http_response[1]
-
-      next if !messages.length
-
-      ## Run user Callback and Reconnect if user permits.
-      ## Capture the message and encrypt it
-      if @cipher_key.length > 0
-        pc = PubnubCrypto.new(@cipher_key)
-        messages.each do |message|
-          if message.is_a? Array
-            message=pc.decryptArray(message)
-          else
-            message=pc.decryptObject(message)
+  def _request(request)
+
+    if (defined?(Rails) && Rails.present? && Rails.env.present?) && Rails.env.test?
+
+      open(request.url, 'r', :read_timeout => 300) do |response|
+        request.package_response!(response.read)
+        request.callback.call(request.response)
+        request.response
+      end
+
+    else
+
+      request.format_url!
+      #puts("- Fetching #{request.url}")
+
+      begin
+
+        EM.run do
+
+          conn = PubnubDeferrable.connect request.host, request.port
+          conn.pubnub_request = request
+          req = conn.get(request.query)
+
+          timeout_timer = EM.add_periodic_timer(290) do
+            #puts("#{Time.now}: Reconnecting from timeout.")
+            reconnect_and_query(conn, request)
           end
-          if !callback.call(message)
-            return
+
+          error_timer = EM.add_periodic_timer(5) do
+            #puts("#{Time.now}: Checking for errors.")
+            if conn.error?
+
+              error_message = "Intermittent Error: #{response.status}, extended info: #{response.internal_error}"
+              puts(error_message)
+              request.callback.call([0, error_message])
+
+              reconnect_and_query(conn, request)
+            end
           end
-        end
-      else
-        messages.each do |message|
-          if !callback.call(message)
-            return
+
+          req.errback do |response|
+            conn.close_connection
+            error_message = "Unknown Error: #{response.to_s}"
+
+            puts(error_message)
+            request.callback.call([0, error_message])
+
+            reconnect_and_query(conn, request)
           end
-        end
-      end
 
-      request = [ 'subscribe', @subscribe_key, channel, '0', timetoken.to_s ]
-      args['request'] = request
-      # Recusive call to _subscribe
-      _subscribe(args)
-    end
-  end
+          req.callback do |response|
+
+            if response.status != 200
+              error_message = "Server Error, status: #{response.status}, extended info: #{response.internal_error}"
+
+              puts(error_message)
+              request.callback.call([0, error_message])
+
+              conn.reconnect request.host, request.port
+            end
+
+            request.package_response!(response.content)
+            request.callback.call(request.response)
+
+            EM.next_tick do
+              if %w(subscribe presence).include?(request.operation)
+                conn.close_connection
 
-  #**
-  #* Request URL
-  #*
-  #* @param array request of url directories.
-  #* @return array from JSON response.
-  #*
-  def _request(args)
-    request  = args['request']
-    callback = args['callback']
-    url = encode_URL(request)
-    url = @origin + url
-      open(url) do |f|
-        response = JSON.parse(f.read)
-        if request[0] == 'history'
-          if @cipher_key.length > 0
-            myarr=Array.new()
-            response.each do |message|
-              pc=PubnubCrypto.new(@cipher_key)
-              if message.is_a? Array
-                message=pc.decryptArray(message)
+                timeout_timer.cancel
+                error_timer.cancel
+
+                _request(request)
               else
-                message=pc.decryptObject(message)
+                conn.close_connection
+                return request.response
+
               end
-              myarr.push(message)
+
             end
-            callback.call(myarr)
-          else
-            callback.call(response)
           end
-        elsif request[0] == 'publish'
-          callback.call(response)
-        else
-          callback.call(response)
         end
+
+      rescue EventMachine::ConnectionError => e
+        error_message = "Network Error: #{e.message}"
+        puts(error_message)
+        return [0, error_message]
       end
+
+    end
   end
 
-  def encode_URL(request)
-    ## Construct Request URL
-    url = '/' + request.map{ |bit| bit.split('').map{ |ch|
-        ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.index(ch) ?
-        '%' + ch.unpack('H2')[0].to_s.upcase : URI.encode(ch)
-      }.join('') }.join('/')
-    return url
+  def reconnect_and_query(conn, request)
+    conn.reconnect request.host, request.port
+    conn.pubnub_request = request
+    conn.get(request.query)
   end
+
 end