pubnub 3.3.0.7 → 3.4

data/lib/pubnub/configuration.rb

@@ -0,0 +1,25 @@
+module Pubnub
+  module Configuration
+    DEFAULT_SECRET_KEY         = 0
+    DEFAULT_TIMETOKEN          = 0
+    DEFAULT_ORIGIN             = 'pubsub.pubnub.com'
+    DEFAULT_PORT               = 80
+    DEFAULT_METHOD             = 'GET'
+    DEFAULT_CONTENT_TYPE       = 'application/json'
+    DEFAULT_PATH               = '/'
+    DEFAULT_PARAMS             = {}
+    DEFAULT_HEADERS            = {}
+    DEFAULT_USER_AGENT         = "Pubnub Ruby #{PUBNUB_VERSION}"
+    DEFAULT_SSL_SET            = false
+    DEFAULT_TIMEOUT            = 5
+    DEFAULT_ENCODING           = nil
+    DEFAULT_AUTO_RECONNECT     = true
+    DEFAULT_CALLBACK           = lambda { |data| puts data }
+    DEFAULT_PUBLISH_KEY        = 'demo'
+    DEFAULT_SUBSCRIBE_KEY      = 'demo'
+    DEFAULT_CHANNEL            = 'hello_world'
+    PERIODIC_TIMER             = 0.25
+    MAX_RETRIES                = 60
+  end
+end
+

data/lib/pubnub/crypto.rb

@@ -0,0 +1,53 @@
+module Pubnub
+  class Crypto
+    def initialize(cipher_key)
+      @alg = 'AES-256-CBC'
+      sha256_key = Digest::SHA256.hexdigest(cipher_key)
+      @key = sha256_key.slice(0,32)
+
+      @iv = '0123456789012345'
+    end
+
+
+    def encrypt(message)
+
+      aes = OpenSSL::Cipher::Cipher.new(@alg)
+      aes.encrypt
+      aes.key = @key
+      aes.iv = @iv
+
+      json_message = message.to_json
+      cipher = aes.update(json_message)
+      cipher << aes.final
+
+      Base64.strict_encode64(cipher)
+
+    end
+
+
+    def decrypt(cipher_text)
+      decode_cipher = OpenSSL::Cipher::Cipher.new(@alg)
+      decode_cipher.decrypt
+      decode_cipher.key = @key
+      decode_cipher.iv = @iv
+
+      plain_text = ''
+
+      begin
+        undecoded_text = Base64.decode64(cipher_text)
+        plain_text = decode_cipher.update(undecoded_text)
+        plain_text << decode_cipher.final
+      rescue => e
+        return "DECRYPTION_ERROR #{e}"
+      end
+
+      begin
+        JSON.load(plain_text)
+      rescue JSON::ParserError
+        JSON.load("[#{plain_text}]")[0] # srsly ruby? srsly?
+      rescue
+        return 'PARSE DECRYPTION MESSAGE ERROR'
+      end
+    end
+  end
+end

data/lib/pubnub/error.rb

@@ -0,0 +1,23 @@
+module Pubnub
+  module Error
+    class PresenceError  < RuntimeError;
+    end
+    class PublishError   < RuntimeError;
+    end
+    class SubscribeError < RuntimeError;
+    end
+    class InitError      < RuntimeError;
+    end
+    class PublishError   < RuntimeError;
+    end
+    class OperationError < RuntimeError
+      def operation_exception
+        #if @operation.present?
+        #  ("Pubnub::" + @operation.to_s.capitalize + "Error").constantize
+        #else
+          PubnubRequest::RequestError
+        #end
+      end
+    end
+  end
+end

data/lib/pubnub/request.rb

@@ -0,0 +1,288 @@
+require 'pubnub/configuration.rb'
+require 'pubnub/error.rb'
+require 'pubnub/response.rb'
+
+require 'openssl'
+require 'digest/sha2'
+require 'base64'
+
+require 'json'
+
+module Pubnub
+  class Request
+    include Pubnub::Configuration
+    include Pubnub::Error
+
+    attr_accessor :error_callback, :envelopes, :port, :timetoken, :operation, :response, :ssl, :channel, :callback, :cipher_key, :subscribe_key, :secret_key, :operation, :message, :publish_key
+
+    def initialize(options = {})
+      @options = options
+
+      @params         = options[:params]
+      @operation      = options[:operation]
+      @callback       = options[:callback]
+      @error_callback = options[:error_callback]
+      @error_callback = lambda { |x| puts "AN ERROR OCCURRED: #{x.msg}" } unless @error_callback
+      @channel        = options[:channel]
+      @message        = options[:message]
+      @timetoken      = options[:timetoken] || "0"
+      @timetoken      = options[:override_timetoken] if options[:override_timetoken]
+      @ssl            = options[:ssl]
+      @params         = options[:params]
+
+      @history_limit  = options[:limit]
+
+      @port           = options[:port]
+      @host           = options[:origin]
+      @query          = options[:query]
+
+      set_cipher_key(options, @cipher_key) if %w(publish subscribe history).include? @operation
+      set_message(options, @cipher_key) if %w(publish).include? @operation
+      set_publish_key(options, @publish_key) if %w(publish).include? @operation
+      set_subscribe_key(options, @subscribe_key) if %w(publish presence here_now history subscribe leave).include? @operation
+      set_secret_key(options, @secret_key) if %w(publish subscribe).include? @operation
+
+    end
+
+    def ssl=(ssl)
+      if ssl
+        @ssl = true
+        @port = 443
+      else
+        @ssl = false
+        @port = 80
+      end
+    end
+
+    def origin
+      if @ssl
+        @origin = 'https://' + @host
+        @port = 443
+      else
+        @origin = 'http://' + @host
+        @port = 80
+      end
+      @origin
+    end
+
+    def path
+      encode_path(case @operation
+                   when 'publish'
+                     [
+                         @operation,
+                         @publish_key,
+                         @subscribe_key,
+                         @secret_key,
+                         @channel,
+                         '0',
+                         @message.to_json
+                     ]
+                   when 'subscribe'
+                     [
+                         @operation,
+                         @subscribe_key,
+                         @channel,
+                         '0',
+                         @timetoken
+                     ]
+                   when 'presence'
+                     [
+                         'subscribe',
+                         @subscribe_key,
+                         @channel.to_s + '-pnpres',
+                         '0',
+                         @timetoken
+                     ]
+                   when 'time'
+                     [
+                         @operation,
+                         '0'
+                     ]
+                   when 'history'
+                     [
+                         'v2',
+                         'history',
+                         'sub-key',
+                         @subscribe_key,
+                         'channel',
+                         @channel
+                     ]
+                    when 'here_now'
+                      [
+                          'v2',
+                          'presence',
+                          'sub-key',
+                          @subscribe_key,
+                          'channel',
+                          @channel
+                      ]
+                    when 'leave'
+                      [
+                          'v2',
+                          'presence',
+                          'sub-key',
+                          @subscribe_key,
+                          'channel',
+                          @channel
+                      ]
+                    else
+                     raise("I can't create that URL for you due to unknown operation type.")
+                 end
+      )
+    end
+
+    def encode_path(request)
+      $log.debug 'ENCODING PATH'
+      path = URI.escape('/' + request.map{|i| i.to_s}.reject(&:empty?).join('/')).gsub(/\?/,'%3F')
+      if @operation == 'leave'
+        $log.debug "#{path}/leave"
+        "#{path}/leave"
+      else
+        $log.debug path
+        path
+      end
+    end
+
+    def params
+      flat = {}
+      @params.each do |param,val|
+        next if val.to_s.empty?
+        flat[param.to_s] = val.to_s
+      end
+      flat
+    end
+
+    def query
+      params.map do |param, value|
+        [param, value].join('=')
+      end.sort.join('&')
+    end
+
+    def handle_response(http)
+      @response = nil
+
+      if http.respond_to?(:body) && http.respond_to?(:code) && http.respond_to?(:message) && http.respond_to?(:headers) # httparty
+        @response = JSON.load(http.body)
+      else # em-http-request
+        @response = http.response.respond_to?(:content) ? JSON.load(http.response.content) : JSON.load(http.response)
+      end
+
+
+      @last_timetoken = @timetoken
+      @timetoken = @response[1] unless @operation == 'time'
+
+      if @cipher_key.present? && %w(subscribe history).include?(@operation)
+
+        response_array = Array.new
+        crypto = Pubnub::Crypto.new(@cipher_key)
+
+        if %w(subscribe history).include?(@operation)
+          iteration = @response[0]
+        else
+          iteration = @response
+        end
+
+        if iteration.class == Array
+          iteration.each do |msg|
+            response_array << crypto.decrypt(msg)
+          end if iteration
+        elsif iteration.class == String
+          response_array = [crypto.decrypt(iteration)]
+        end
+
+        case @operation
+          when 'subscribe'
+            @response[0] = response_array
+          when 'history'
+            json_response_data = JSON.load(http.response)
+            @response = [response_array, json_response_data[1], json_response_data[2]]
+        end
+      end
+
+      @envelopes = Array.new
+      if %w(subscribe history).include? @operation
+        @response.first.each_with_index do |res,index|
+          @envelopes << Pubnub::Response.new(:http => http, :index => index, :response => @response, :channel => @channel, :operation => @operation, :path => path, :query => query)
+        end
+      else
+        @envelopes << Pubnub::Response.new(:http => http, :channel => @channel, :response => @response, :operation => @operation, :path => path, :query => query)
+      end
+    end
+
+
+    private
+
+    def aes_encrypt(cipher_key, options, publish_request)
+
+      pc = Pubnub::Crypto.new(cipher_key)
+      publish_request.message = pc.encrypt(options[:message])
+
+    end
+
+    def set_cipher_key(options, self_cipher_key)
+      if self_cipher_key.present? && options[:cipher_key].present?
+        raise(OperationError, "existing cipher_key #{self_cipher_key} cannot be overridden at publish-time.")
+
+      elsif (self_cipher_key.present? && options[:cipher_key].blank?) || (self_cipher_key.blank? && options[:cipher_key].present?)
+
+        this_cipher_key = self_cipher_key || options[:cipher_key]
+        raise(OperationError, 'secret key must be a string.') if this_cipher_key.class != String
+        @cipher_key = this_cipher_key
+      end
+    end
+
+    def set_secret_key(options, self_secret_key)
+      if self_secret_key.present? && options[:secret_key].present?
+        raise(OperationError, "existing secret_key #{self_secret_key} cannot be overridden at publish-time.")
+
+      elsif (self_secret_key.present? && options[:secret_key].blank?) || (self_secret_key.blank? && options[:secret_key].present?)
+
+        my_secret_key = self_secret_key || options[:secret_key]
+        raise(OperationError, 'secret key must be a string.') if my_secret_key.class != String
+
+        signature       = '{ @publish_key, @subscribe_key, @secret_key, channel, message}'
+        digest          = OpenSSL::Digest.new('sha256')
+        key             = [my_secret_key]
+        hmac            = OpenSSL::HMAC.hexdigest(digest, key.pack('H*'), signature)
+        @secret_key = hmac
+      else
+        @secret_key = '0'
+      end
+    end
+
+    def set_message(options, self_cipher_key)
+      if options[:message].blank? && options[:message] != ''
+        raise(OperationError, 'message is a required parameter.')
+      else
+        my_cipher_key = options[:cipher_key] || self_cipher_key
+
+        if my_cipher_key.present?
+          @message = aes_encrypt(my_cipher_key, options, self)
+        else
+          @message = options[:message]
+        end
+      end
+    end
+
+    def set_publish_key(options, self_publish_key)
+      if options[:publish_key].blank? && self_publish_key.blank?
+        raise(OperationError, 'publish_key is a required parameter.')
+      elsif self_publish_key.present? && options[:publish_key].present?
+        raise(OperationError, "existing publish_key #{self_publish_key} cannot be overridden at publish-time.")
+      else
+        @publish_key = (self_publish_key || options[:publish_key]).to_s
+      end
+    end
+
+    def set_subscribe_key(options, self_subscribe_key)
+      if options[:subscribe_key].blank? && self_subscribe_key.blank?
+        raise(OperationError, 'subscribe_key is a required parameter.')
+      elsif self_subscribe_key.present? && options[:subscribe_key].present?
+        raise(OperationError, "existing subscribe_key #{self_subscribe_key} cannot be overridden at subscribe-time.")
+      else
+        @subscribe_key = (self_subscribe_key || options[:subscribe_key]).to_s
+      end
+    end
+
+  end
+end

data/lib/pubnub/response.rb

@@ -0,0 +1,126 @@
+class Pubnub::Response
+  attr_reader :message, :channel, :timetoken, :status_code
+  attr_reader :response, :path, :query
+  alias :msg :message
+
+  # Creates Pubnub::Response object based on options hash
+  #
+  # Sets @message, @channel, @timetoken, @status_code, :response attributes
+  # @message contains usable single message for callback
+  # @channel contains channel which was used in request
+  # @timetoken contains server timetoken
+  # @status_code contains status code of server response
+  # @response contains whole server response body which was used to build that Pubnub::Response
+  # @headers contains whole server response headers
+  #
+  # To properly init new response object it need :http, :response, :channel options
+  # While you pass :index option it will treat :response as array which size is greater than one
+  # In case you want create your custom error response, you have to pass :error_init option with true value and :message with your message
+  def initialize(options = {})
+    @path  = options[:path]
+    @query = options[:query]
+
+    if options[:error_init]
+      @message = options[:message]
+      @response = options[:message]
+      @timetoken = 0
+    else
+      if options[:http].respond_to?(:body) && options[:http].respond_to?(:code) && options[:http].respond_to?(:message) && options[:http].respond_to?(:headers)
+        httparty = true
+      else
+        httparty = false
+      end
+
+      if httparty
+        case options[:operation]
+          when 'publish'
+            set_for_httparty(options)
+          when 'subscribe'
+            set_for_httparty(options)
+          when 'presence'
+            set_for_httparty(options)
+          when 'history'
+            set_for_httparty(options)
+          when 'leave'
+            set_for_httparty(options)
+          when 'here_now'
+            set_for_httparty(options)
+          when 'time'
+            set_for_httparty(options)
+        end
+      else # EM.http_request
+        case options[:operation]
+          when 'publish'
+            set_for_em_http_request(options)
+          when 'subscribe'
+            set_for_em_http_request(options)
+          when 'presence'
+            set_for_em_http_request(options)
+          when 'history'
+            set_for_em_http_request(options)
+          when 'leave'
+            set_for_em_http_request(options)
+          when 'here_now'
+            set_for_em_http_request(options)
+          when 'time'
+            set_for_em_http_request(options)
+        end
+      end
+    end
+  end
+
+  # Simple compare to other object basing on string representation of response
+  # (see #to_s)
+  def ==(other)
+    @response == other.to_s
+  end
+
+  private
+
+  def set_for_httparty(options)
+    if options[:response][2] && options[:operation] == 'subscribe'
+      @channel = options[:index] ? options[:response][2].split(',')[options[:index]] : options[:channel]
+    else
+      @channel = options[:channel]
+    end
+
+    if options[:operation] == 'publish'
+      set_for_publish(options[:response][1],options[:response][2])
+    elsif %w(here_now leave).include? options[:operation]
+      @message = options[:response]
+    else
+      @timetoken = options[:response][1]
+      @message = options[:index] ? options[:response][0][options[:index]] : options[:response][0]
+    end
+
+    @status_code = options[:http].response.code
+    @headers = options[:http].headers.inspect
+    @response = options[:http].body
+  end
+
+  def set_for_em_http_request(options)
+    if options[:response][2] && options[:operation] == 'subscribe'
+      @channel = options[:index] ? options[:response][2].split(',')[options[:index]] : options[:channel]
+    else
+      @channel = options[:channel]
+    end
+
+    if options[:operation] == 'publish'
+      set_for_publish(options[:response][1],options[:response][2])
+    elsif %w(here_now leave).include? options[:operation]
+      @message = options[:response]
+    else
+      @timetoken = options[:response][1]
+      @message = options[:index] ? options[:response][0][options[:index]] : options[:response][0]
+    end
+
+    @status_code = options[:http].response_header.status.to_i
+    @headers = options[:http].response_header
+    @response = options[:http].response
+  end
+
+  def set_for_publish(msg, timetoken)
+    @message = msg
+    @timetoken = timetoken
+  end
+end