pubnub 3.7.12 → 3.8.0

data/fixtures/vcr_cassettes/test_examples/1001086.yml

@@ -0,0 +1,51 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://pubsub.pubnub.com/v2/presence/sub-key/sub-c-719173ee-ff28-11e4-ab7c-0619f8945a4f/uuid/john?pnsdk=PubNub-Ruby/4.0.0beta&uuid=gentest
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+      Connection:
+      - keep-alive
+      Keep-Alive:
+      - 30
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jun 2015 13:46:38 GMT
+      Content-Type:
+      - text/javascript; charset="UTF-8"
+      Content-Length:
+      - '84'
+      Connection:
+      - keep-alive
+      Access-Control-Allow-Origin:
+      - "*"
+      Access-Control-Allow-Methods:
+      - GET
+      Cache-Control:
+      - no-cache
+      Accept-Ranges:
+      - bytes
+      Age:
+      - '3'
+      Server:
+      - Pubnub Presence
+    body:
+      encoding: UTF-8
+      string: '{"status": 200, "message": "OK", "payload": {"channels": []}, "service":
+        "Presence"}'
+    http_version: 
+  recorded_at: Tue, 30 Jun 2015 13:46:38 GMT
+recorded_with: VCR 2.9.3

data/fixtures/vcr_cassettes/test_examples/1001087.yml

@@ -0,0 +1,51 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://pubsub.pubnub.com/v2/presence/sub-key/sub-c-719173ee-ff28-11e4-ab7c-0619f8945a4f/uuid/john?pnsdk=PubNub-Ruby/4.0.0beta&uuid=gentest
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+      Connection:
+      - keep-alive
+      Keep-Alive:
+      - 30
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jun 2015 13:46:36 GMT
+      Content-Type:
+      - text/javascript; charset="UTF-8"
+      Content-Length:
+      - '84'
+      Connection:
+      - keep-alive
+      Access-Control-Allow-Origin:
+      - "*"
+      Access-Control-Allow-Methods:
+      - GET
+      Cache-Control:
+      - no-cache
+      Accept-Ranges:
+      - bytes
+      Age:
+      - '0'
+      Server:
+      - Pubnub Presence
+    body:
+      encoding: UTF-8
+      string: '{"status": 200, "message": "OK", "payload": {"channels": []}, "service":
+        "Presence"}'
+    http_version: 
+  recorded_at: Tue, 30 Jun 2015 13:46:35 GMT
+recorded_with: VCR 2.9.3

data/fixtures/vcr_cassettes/wc-sub-ssl-false-4.yml

@@ -10,7 +10,7 @@ http_interactions:
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
-      - '*/*'
+      - "*/*"
       User-Agent:
       - Ruby
       Connection:
@@ -33,7 +33,7 @@ http_interactions:
       Cache-Control:
       - no-cache
       Access-Control-Allow-Origin:
-      - '*'
+      - "*"
       Access-Control-Allow-Methods:
       - GET
     body:
@@ -51,7 +51,7 @@ http_interactions:
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
-      - '*/*'
+      - "*/*"
       User-Agent:
       - Ruby
       Connection:
@@ -74,7 +74,7 @@ http_interactions:
       Cache-Control:
       - no-cache
       Access-Control-Allow-Origin:
-      - '*'
+      - "*"
       Access-Control-Allow-Methods:
       - GET
     body:
@@ -92,7 +92,7 @@ http_interactions:
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
-      - '*/*'
+      - "*/*"
       User-Agent:
       - Ruby
       Connection:
@@ -115,7 +115,7 @@ http_interactions:
       Cache-Control:
       - no-cache
       Access-Control-Allow-Origin:
-      - '*'
+      - "*"
       Access-Control-Allow-Methods:
       - GET
     body:
@@ -134,7 +134,7 @@ http_interactions:
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
-      - '*/*'
+      - "*/*"
       User-Agent:
       - Ruby
       Connection:
@@ -157,7 +157,7 @@ http_interactions:
       Cache-Control:
       - no-cache
       Access-Control-Allow-Origin:
-      - '*'
+      - "*"
       Access-Control-Allow-Methods:
       - GET
     body:
@@ -165,4 +165,44 @@ http_interactions:
       string: '[[{"text":"hey"}],"14376642302336303","foo","foo"]'
     http_version: 
   recorded_at: Thu, 23 Jul 2015 15:10:30 GMT
-recorded_with: VCR 2.9.2
+- request:
+    method: get
+    uri: http://pubsub.pubnub.com/v2/presence/sub-key/sub-c-53c3d30a-4135-11e3-9970-02ee2ddab7fe/channel/whatever/uuid/rubytestuuid/data?pnsdk=PubNub-Ruby/4.0.0beta7&state=%7B%22key%22:%22value%22%7D&uuid=rubytestuuid
+    body:
+      encoding: UTF-8
+      string: ''
+    headers:
+      User-Agent:
+      - HTTPClient/1.0 (2.6.0.1, ruby 2.2.2 (2015-04-13))
+      Accept:
+      - "*/*"
+      Date:
+      - Tue, 27 Oct 2015 17:39:16 GMT
+  response:
+    status:
+      code: 400
+      message: Bad Request
+    headers:
+      Date:
+      - Tue, 27 Oct 2015 17:39:18 GMT
+      Content-Type:
+      - text/javascript; charset=UTF-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - close
+      Access-Control-Allow-Origin:
+      - "*"
+      Access-Control-Allow-Methods:
+      - GET
+      Access-Control-Allow-Headers:
+      - Origin, X-Requested-With, Content-Type, Accept
+      Cache-Control:
+      - max-age=300
+    body:
+      encoding: UTF-8
+      string: |
+        {"message":"Invalid Subscribe Key","payload":{"channels":["whatever"]},"error":true,"service":"Access Manager","status":400}
+    http_version: 
+  recorded_at: Tue, 27 Oct 2015 17:39:18 GMT
+recorded_with: VCR 2.9.3

data/lib/pubnub.rb

@@ -1,26 +1,17 @@
-## www.pubnub.com - PubNub realtime push service in the cloud.
-## http://www.pubnub.com/blog/ruby-push-api - Ruby Push API Blog
-
-## PubNub Real Time Push APIs and Notifications Framework
-## Copyright (c) 2014 PubNub
-## http://www.pubnub.com/
-
-## -----------------------------------
-## PubNub Real-time Push Cloud API
-## -----------------------------------
-
 require 'json'
 require 'base64'
+require 'zlib'
 require 'open-uri'
 require 'openssl'
-require 'eventmachine'
-require 'net/http/persistent'
+require 'celluloid/current'
+require 'timers'
+require 'httpclient'
 require 'logger'
 
 require 'pubnub/version'
 require 'pubnub/client'
 
-
+# Adding blank? and present? methods to Object.
 class Object
   def blank?
     respond_to?(:empty?) ? empty? : !self
@@ -31,23 +22,14 @@ class Object
   end
 end
 
-class Proc
-  def try(*a, &b)
-    if a.empty? && block_given?
-      yield self
-    else
-      __send__(*a, &b)
-    end
-  end
-end
-
+# Toplevel Pubnub module.
 module Pubnub
   class << self
-    attr_accessor :logger
+    attr_accessor :logger, :client
 
+    # TODO: docs
     def new(options = {})
       Pubnub::Client.new(options)
     end
   end
 end
-

data/lib/pubnub/client.rb

@@ -1,375 +1,409 @@
-require 'pubnub/configuration'
-require 'pubnub/parser'
-require 'pubnub/envelope'
-require 'pubnub/crypto'
+require 'pubnub/error'
 require 'pubnub/uuid'
-require 'pubnub/exceptions'
-require 'pubnub/event'
 require 'pubnub/formatter'
-require 'pubnub/validator'
+require 'pubnub/crypto'
+require 'pubnub/configuration'
+require 'pubnub/message'
+
+require 'pubnub/event'
+require 'pubnub/single_event'
+require 'pubnub/subscribe_event/callbacks'
+require 'pubnub/subscribe_event/formatter'
+require 'pubnub/subscribe_event/heartbeat'
+require 'pubnub/subscribe_event/adding'
+require 'pubnub/subscribe_event/removing'
+require 'pubnub/subscribe_event'
 require 'pubnub/pam'
+require 'pubnub/heart'
+require 'pubnub/subscriber'
 
+require 'pubnub/envelope'
+require 'pubnub/error_envelope'
+
+require 'pubnub/client/connections'
+require 'pubnub/client/events'
+require 'pubnub/client/paged_history'
+require 'pubnub/client/helpers'
+
+require 'pubnub/validators/common_validator'
+require 'pubnub/validators/client'
+require 'pubnub/validators/audit'
+require 'pubnub/validators/channel_registration'
+require 'pubnub/validators/grant'
+require 'pubnub/validators/heartbeat'
+require 'pubnub/validators/here_now'
+require 'pubnub/validators/history'
+require 'pubnub/validators/leave'
+require 'pubnub/validators/presence'
+require 'pubnub/validators/publish'
+require 'pubnub/validators/revoke'
+require 'pubnub/validators/set_state'
+require 'pubnub/validators/state'
+require 'pubnub/validators/subscribe'
+require 'pubnub/validators/time'
+require 'pubnub/validators/where_now'
+
+require 'pubnub/events/audit'
+require 'pubnub/events/channel_registration'
+require 'pubnub/events/grant'
+require 'pubnub/events/heartbeat'
+require 'pubnub/events/here_now'
+require 'pubnub/events/history'
+require 'pubnub/events/leave'
+require 'pubnub/events/presence'
+require 'pubnub/events/publish'
+require 'pubnub/events/revoke'
+require 'pubnub/events/set_state'
+require 'pubnub/events/state'
+require 'pubnub/events/subscribe'
+require 'pubnub/events/time'
+require 'pubnub/events/where_now'
+
+# Toplevel Pubnub module.
 module Pubnub
+  # Pubnub client Class.
   class Client
     include Configuration
+    include Connections
+    include Events
+    include PagedHistory
+    include Helpers
 
-    attr_reader :env
-    attr_accessor :single_event_connections_pool, :subscribe_event_connections_pool, :uuid, :async_events
+    attr_reader :env, :subscriber
 
-    EVENTS = %w(publish subscribe presence leave history here_now audit grant revoke time heartbeat where_now state set_state channel_registration)
     VERSION = Pubnub::VERSION
 
-    EVENTS.each do |event_name|
-      require File.join('pubnub', 'events', event_name)
-    end
-
-    EVENTS.each do |event_name|
-      define_method event_name do |params = {}, &block|
-        params[:callback] = block if params[:callback].nil?
-        event = Pubnub.const_get(classify_method(event_name)).new(params, self)
-        Pubnub.logger.debug(:pubnub){'Created event ' + event.class.to_s}
-        event.fire(self)
-      end
-    end
-    alias_method :unsubscribe, :leave
-
+    # Parameters:
+    # ===========
+    #
+    # <dl>
+    #   <dt>subscribe_key</dt>
+    #   <dd><b>required.</b> Your subscribe key.</dd>
+    #
+    #   <dt>publish_key</dt>
+    #   <dd><b>optional.</b> Your publish key, without it you can't push messages.</dd>
+    #
+    #   <dt>secret_key</dt>
+    #   <dd><b>optional.</b> Your secret key, required for PAM operations.</dd>
+    #
+    #   <dt>auth_key</dt>
+    #   <dd><b>optional.</b> This client auth key.</dd>
+    #
+    #   <dt>cipher_key</dt>
+    #   <dd><b>optional.</b> Required to encrypt messages.</dd>
+    #
+    #   <dt>uuid</dt>
+    #   <dd><b>optional.</b> Sets given uuid as client uuid, does not generates random uuid on init as usually.</dd>
+    #
+    #   <dt>origin</dt>
+    #   <dd><b>optional.</b> Specifies the fully qualified domain name of the PubNub origin.
+    #     By default this value is set to <code>pubsub.pubnub.com</code> but it should be set to the appropriate origin
+    #     specified in the PubNub Admin Portal.</dd>
+    #
+    #   <dt>callback</dt>
+    #   <dd><b>optional.</b> Default callback function for all events if not overwrote while firing event.</dd>
+    #
+    #   <dt>error_callback</dt>
+    #   <dd><b>optional.</b> Default error callback.</dd>
+    #
+    #   <dt>connect_callback</dt>
+    #   <dd><b>optional.</b> Callback that is called when connection with origin is established.
+    #                        It should take string as parameter.</dd>
+    #
+    #   <dt>disconnect_callback</dt>
+    #   <dd><b>optional.</b> Callback that is called when connection with origin is teared down
+    #                        (it's called each time when reestablishing connection didn't work).
+    #                        It should take string as parameter.</dd>
+    #
+    #   <dt>reconnect_callback</dt>
+    #   <dd><b>optional.</b> Callback that is called when connection with origin is reestablished.
+    #                        It should take string as parameter.</dd>
+    #
+    #   <dt>ssl</dt>
+    #   <dd><b>optional.</b> Your connection will use ssl if set to true.</dd>
+    #
+    #   <dt>heartbeat</dt>
+    #   <dd><b>optional.</b> Heartbeat interval, if not set heartbeat will not be running.</dd>
+    #
+    #   <dt>subscribe_timeout</dt>
+    #   <dd><b>optional, be careful when modifying this.</b> Timeout for subscribe connection in seconds.</dd>
+    #
+    #   <dt>non_subscribe_timeout</dt>
+    #   <dd><b>optional, be careful when modifying this.</b> Timeout for non-subscribe connection in seconds.</dd>
+    #
+    #   <dt>max_retries</dt>
+    #   <dd><b>optional.</b> How many times client should try to reestablish connection before fail.</dd>
+    #
+    #   <dt>ttl</dt>
+    #   <dd><b>optional.</b> Default ttl for grant and revoke events.</dd>
+    # </dl>
+    # _examples:_
+    # ```ruby
+    # # Minimal initialize
+    # pubnub = Pubnub.new(subscribe_key: :my_sub_key)
+    # ````
+    #
+    # ```ruby
+    # # More complex initialize
+    # pubnub = Pubnub.new(
+    #   subscribe_key: :demo,
+    #   publish_key: :demo,
+    #   secret_key: :secret,
+    #   cipher_key: :other_secret,
+    #   uuid: :mad_max,
+    #   origin: 'custom.pubnub.com',
+    #   callback: -> (envelope) { puts envelope.message },
+    #   error_callback: -> (envelope) { puts envelope.message },
+    #   connect_callback: -> (message) { puts message },
+    #   heartbeat: 60,
+    #   subscribe_timeout: 310,
+    #   non_subscribe_timeout: 10,
+    #   max_retries: 10,
+    #   ttl: 0
+    # )
+    # ```
+    # Returns:
+    # ========
+    #
+    # Initialized Pubnub::Client ready to use.
+    #
     def initialize(options)
-      validate!(options)
-      setup_app(options) # After that we have to use @env in that method instead of options
-      create_connections_pools(@env)
-      create_subscriptions_pools(@env)
-      # start_event_machine(@env)
+      env_hash = symbolize_options_keys(options)
+      setup_app env_hash
+      clean_env
+      prepare_env
+      validate! @env
+      Pubnub.logger.info('Pubnub::Client') do
+        "Created new Pubnub::Client instance. Version: #{Pubnub::VERSION}"
+      end
     end
 
-    def paged_history(options = {}, &block)
-      channel  = options[:channel]
-      page     = options[:page]      || 1
-      limit    = options[:limit]     || 100
-      callback = options[:callback]  || block
-      sync     = options[:http_sync] ? true : false
-      start_tt = options[:start]     || nil
-      end_tt   = options[:end]       || nil
-
-      current_start_tt = start_tt
-
-      if sync
-        envelopes = []
-        page.times do |i|
-          Pubnub.logger.debug(:pubnub){"\n\nFetching page no. #{i}"}
-          Pubnub.logger.debug(:pubnub){"Current start tt #{current_start_tt}\n"}
-          envelopes << history(:channel => channel, :http_sync => true, :count => limit, :start => current_start_tt, :end => end_tt)
-          envelopes.flatten!
-
-          Pubnub.logger.debug(:pubnub){"\n\nHistroy start: #{envelopes.last.history_start}"}
-          Pubnub.logger.debug(:pubnub){"History end: #{envelopes.last.history_end}\n"}
-          current_start_tt = envelopes.last.history_start.to_i
-
-          unless i == page - 1
-            envelopes = []
-          end
-        end
-
-        envelopes.flatten!
-        envelopes.each do |envelope|
-          callback.call envelope
-        end if callback
-        envelopes
+    # Returns:
+    # ========
+    # True if client is subscribed to at least one channel or channel group, otherwise false.
+    def subscribed?
+      if @env[:subscription_pool].empty?
+        false
       else
-        start_event_machine
-        EM.defer do
-          sync_options = options.dup
-          sync_options[:http_sync] = true
-          self.paged_history(sync_options, &block)
-        end
+        !@env[:subscription_pool].map(&:empty?).index(false)
       end
     end
 
-    def state_for(origin = DEFAULT_ORIGIN)
-      @env[:state][origin]
-    end
-
-    def shutdown(stop_em = false)
-      @single_event_connections_pool.each do |origin, conn|
-        conn.shutdown_in_all_threads
-        conn = nil
+    # Parameters:
+    # ===========
+    # <dl>
+    #   <dt>origin</dt>
+    #   <dd>Domain name where connection should be connected.</dd>
+    #
+    #   <dt>event_type</dt>
+    #   <dd>Keyword. :subscribe_event or :single_event.</dd>
+    #
+    #   <dt>sync</dt>
+    #   <dd>Boolean. True if we want dispatcher for sync or sync event, otherwise false.</dd>
+    # </dl>
+    #
+    # Returns:
+    # ========
+    # Appropriate RequestDispatcher.
+    #
+    # It returns always new RequestDispatcher for sync events.
+    # For async events it checks if there's already RequestDispatcher
+    # created and returns it if created, otherwise creates it, assigns
+    # it in @env and returns newly created dispatcher.
+    def request_dispatcher(origin, event_type, sync)
+      Pubnub.logger.debug('Pubnub::Client') do
+        "Looking for requester for #{event_type}"
       end
-      @single_event_connections_pool = Hash.new
 
-      @subscribe_event_connections_pool.each do |origin, conn|
-        conn.shutdown_in_all_threads
-        conn = nil
+      if sync
+        @env[:req_dispatchers_pool][:sync][origin] ||= {}
+        @env[:req_dispatchers_pool][:sync][origin][event_type] ||=
+            setup_httpclient(event_type)
+      else
+        @env[:req_dispatchers_pool][:async][origin] ||= {}
+        @env[:req_dispatchers_pool][:async][origin][event_type] ||=
+            setup_httpclient(event_type)
       end
-      @subscribe_event_connections_pool = Hash.new
-
-      @env[:callback_pool] = Hash.new
-      @env[:subscriptions] = Hash.new
-
-      EM.stop if stop_em
-
-      Pubnub.logger.info(:pubnub){'Bye!'}
     end
 
-    def stop_async
-      Pubnub.logger.debug(:pubnub){'Pubnub::Client#stop_async | fired'}
-      @env[:subscribe_railgun].cancel unless @env[:subscribe_railgun].blank?
-      @env[:respirator].cancel        unless @env[:respirator].blank?
-      @env[:subscribe_railgun].cancel unless @env[:subscribe_railgun].blank?
-
-      @env[:subscribe_railgun] = nil
-      @env[:respirator] = nil
-      @env[:subscribe_railgun] = nil
-
-      EM.stop
-
-      Pubnub.logger.debug(:pubnub){'Pubnub::Client#stop_async | timers killed'}
-    end
-
-    def restore_async
-      start_event_machine
-      start_subscribe unless @env[:subscriptions].blank?
-      start_railgun
-    end
-
-    def start_respirator
-      Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_respirator | fired'}
-      if @env[:heartbeat]
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_respirator | starting'}
-
-        if @env[:heartbeat] != @env[:respirator].interval
-          Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_respirator | destroy old respirator'}
-          @env[:respirator].cancel
-          @env[:respirator] = nil
-        end if @env[:respirator]
-
-        @env[:respirator] = EM.add_periodic_timer((@env[:heartbeat].to_i/2) - 1) do
-          @env[:subscriptions].each do |origin, subscribe|
-            Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_respirator | BUM'}
-            EM.defer { heartbeat(:channel => subscribe.get_channels, :group => subscribe.get_channel_groups ){ |e| Pubnub.logger.debug('Pubnub::Client#start_respirator | bum') } }
-          end
-        end unless @env[:respirator]
-
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_respirator | started'}
-      end
+    # Parameters:
+    # ===========
+    # <dl>
+    #   <dt>origin</dt>
+    #   <dd>Domain name where connection should be connected.</dd>
+    #
+    #   <dt>event_type</dt>
+    #   <dd>Keyword. :subscribe_event or :single_event.</dd>
+    # </dl>
+    #
+    # Functionality:
+    # ==============
+    # Terminates request dispatcher for given origin and event type. Usable while restarting subscription.
+    def kill_request_dispatcher(origin, event_type)
+      Pubnub.logger.debug('Pubnub::Client') { 'Killing requester' }
+      # @env[:req_dispatchers_pool][origin][event_type].async.terminate
+      @env[:req_dispatchers_pool][:async][origin][event_type].reset_all
+      @env[:req_dispatchers_pool][:async][origin][event_type] = nil
+    rescue
+      Pubnub.logger.debug('Pubnub::Client') { 'There\'s no requester' }
     end
 
-    def start_subscribe(override = false)
-
-      start_event_machine
-      start_respirator if @env[:heartbeat]
-
-      if override
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_subscribe | Override'}
-        @env[:subscribe_railgun].cancel
-        @env[:subscribe_railgun] = nil
-        @env[:wait_for_response].each do |k,v|
-          @env[:wait_for_response][k] = false
-        end
-      end
-
-      if @env[:subscribe_railgun] && @subscribe_deffered_thread
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_subscribe | Aborting previous request'}
-        @subscribe_deffered_thread.kill
-        Thread.pass until @subscribe_deffered_thread.status == false
-      end
-
-      @env[:wait_for_response] = Hash.new unless @wait_for_response
-      unless @env[:subscribe_railgun]
-        @env[:subscribe_railgun] = EM.add_periodic_timer(PERIODIC_TIMER_INTERVAL) do
-          begin
-            @env[:subscriptions].each do |origin, subscribe|
-              unless @env[:wait_for_response][origin]
-                @env[:wait_for_response][origin] = true
-
-                Pubnub.logger.debug(:pubnub){'Async subscription running'}
-                Pubnub.logger.debug(:pubnub){"origin: #{origin}"}
-                Pubnub.logger.debug(:pubnub){"timetoken: #{@env[:timetoken]}"}
-
-                EM.defer do
-                  @subscribe_deffered_thread = Thread.current
-                  subscribe.start_event(self) if subscribe
-                  # @env[:wait_for_response][origin] = false # moved to Event
-                end
-
-              end
-            end
-          rescue => e
-            Pubnub.logger.error(:pubnub){e}
-            Pubnub.logger.error(:pubnub){e.backtrace}
-          end
-        end
+    # Parameters:
+    # ===========
+    # <dl>
+    #   <dt>uuid</dt>
+    #   <dd>New uuid to be set.</dd>
+    # </dl>
+    #
+    # Returns:
+    # ========
+    # New uuid.
+    #
+    # Functionality:
+    # ==============
+    # Can't change uuid while subscribed. You have to leave every subscribed channel.
+    def change_uuid(uuid)
+      Pubnub.logger.debug('Pubnub::Client') { 'Changing uuid' }
+      if subscribed?
+        fail('Cannot change UUID while subscribed.')
+      else
+        @env[:uuid] = uuid
       end
     end
-
-    def subscription_running?
-      @env[:subscribe_railgun] && !@env[:subscriptions].empty? ? true : false
-    end
-
-    def create_subscriptions_pools(env)
-      @env[:subscriptions]        = Hash.new
-      @env[:callbacks_pool]       = Hash.new
-      @env[:error_callbacks_pool] = Hash.new
+    alias_method :session_uuid=, :change_uuid
+    alias_method :uuid=, :change_uuid
+    alias_method :set_uuid=, :change_uuid
+
+    # Returns:
+    # ========
+    # Current origin.
+    def current_origin
+      @env[:origins_pool].first
     end
+    alias_method :origin, :current_origin
 
-    def update_timetoken(timetoken)
-      @env[:connect_callback].call "New connection to #{@origin}" if @env[:timetoken] == 0 && @env[:connect_callback]
-      @env[:timetoken] = timetoken.to_i
-      Pubnub.logger.debug(:pubnub){"Pubnub::Client#update_timetoken | Current timetoken is eq #{@env[:timetoken]}"}
+    # Returns:
+    # ========
+    # Current client timetoken
+    def timetoken
+      @env[:timetoken]
     end
 
-    def set_uuid(uuid)
-      leave_all unless @env[:subscriptions].empty?
-      @env[:uuid] = uuid
-      start_subscribe(true) unless @env[:subscriptions].empty?
+    # Parameters:
+    # ===========
+    # <dl>
+    #   <dt>timetoken</dt>
+    #   <dd>New timetoken.</dd>
+    # </dl>
+    # Returns:
+    # ========
+    # New timetoken.
+    def timetoken=(timetoken)
+      @env[:timetoken] = timetoken
     end
-    alias_method :session_uuid=, :set_uuid
-    alias_method :uuid=, :set_uuid
 
+    # Returns:
+    # ========
+    # Current uuid.
     def uuid
       @env[:uuid]
     end
 
-    def auth_key
-      @env[:auth_key]
-    end
-
-    def set_auth_key(auth_key)
-      leave_all unless @env[:subscriptions].empty?
-      @env[:auth_key] = auth_key
-      start_subscribe(true) unless @env[:subscriptions].empty?
+    # Returns:
+    # ========
+    # Array of all current events.
+    def events
+      @env[:events]
     end
-    alias_method :auth_key=, :set_auth_key
 
-    def set_heartbeat(heartbeat = nil)
-      if heartbeat
-        @env[:heartbeat] = heartbeat
-      end
+    def heartbeat
       @env[:heartbeat]
     end
-    alias_method :heartbeat=, :set_heartbeat
 
-    def get_heartbeat
-      @env[:heartbeat]
+    def heartbeat=(value)
+      @env[:heartbeat] = value
     end
 
-    def set_cipher_key(cipher_key)
-      @env[:cipher_key] = cipher_key
-    end
-    alias_method :cipher_key=, :set_cipher_key
+    def apply_state(event)
+      Pubnub.logger.debug('Pubnub::Client') { 'Apply state' }
+      create_state_pools(event)
 
-    def start_railgun
-      start_event_machine(@env)
-      if @env[:railgun]
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_railgun | Railgun already initialized'}
-      else
-        Pubnub.logger.debug('Pubnub'){'Pubnub::Client#start_railgun | Initializing railgun'}
-        @env[:railgun] = EM.add_periodic_timer(0.01) do
-          @async_events.each do |event|
-            EM.defer do
-              event.fire(self) unless event.fired?
-            end
-          end
-          @async_events.delete_if {|event| event.finished? }
-        end
+      return unless event.state
+
+      event.channel.each do |channel|
+        @env[:state][event.origin][:channel][channel] = event.state
+      end
+
+      event.group.each do |group|
+        @env[:state][event.origin][:group][group] = event.state
       end
     end
 
-    def disabled_persistent_connection?
-      @env[:disable_persistent_connection].present?
+    def empty_state?
+      return true unless @env[:state]
+      totally_empty @env[:state]
     end
 
     private
 
-    def leave_all
-      @env[:subscriptions].each do |origin, subscribe|
-        leave(
-            :origin => origin,
-            :channel => subscribe.get_channels.map{|c| c.to_s}.join(','),
-            :http_sync => true,
-            :skip_remove => true
-        )
-
-        subscribe.set_timetoken(0)
-      end
+    def create_state_pools(event)
+      @env[:state] ||= {}
+      @env[:state][event.origin] ||= {}
+      @env[:state][event.origin][:channel] ||= {}
+      @env[:state][event.origin][:group] ||= {}
     end
 
-    def start_event_machine(options = nil)
-      Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_event_machine | starting EM in new thread'}
-      if defined?(Thin)
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_event_machine | We\'re running on thin'}
+    def setup_httpclient(event_type)
+      if ENV['HTTP_PROXY']
+        hc = HTTPClient.new(ENV['HTTP_PROXY'])
       else
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_event_machine | We aren\'t running on thin'}
+        hc = HTTPClient.new
       end
-      if EM.reactor_running?
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_event_machine | EM already running'}
-      else
-        Thread.new { EM.run {} }
-        Thread.pass until EM.reactor_running?
-        Pubnub.logger.debug(:pubnub){'Pubnub::Client#start_event_machine | EM started in new thread'}
+
+      case event_type
+      when :subscribe_event
+        hc.receive_timeout = 310
+      when :single_event
+        hc.receive_timeout = 5
       end
+
+      hc
+    end
+
+    def validate!(env)
+      Validator::Client.validate! env
     end
 
     def setup_app(options)
       Pubnub.logger = options[:logger] || Logger.new('pubnub.log')
-      @env = symbolize_options_keys(options)
-      @env = set_default_values(@env)
-      @env.delete_if { |_,v| v.blank? } # nillify if blank
-      @env[:timetoken] = 0
-      @async_events = Array.new
-      Pubnub.logger.debug(:pubnub){"\n\nCreated new Pubnub::Client instance"}
+      Celluloid.logger = Pubnub.logger
+      @subscriber = Subscriber.new(self)
+      @env = options
     end
 
-    def create_connections_pools(options)
-      @subscribe_event_connections_pool = Hash.new
-      @single_event_connections_pool    = Hash.new
+    def prepare_env
+      assign_defaults
+      generate_uuid if @env[:uuid].blank?
+      setup_pools
     end
 
-    def set_default_values(env)
-      defaults = {
-          :error_callback             => DEFAULT_ERROR_CALLBACK,
-          :connect_callback           => DEFAULT_CONNECT_CALLBACK,
-          :ssl                        => DEFAULT_SSL,
-          :timetoken                  => DEFAULT_TIMETOKEN,
-          :uuid                       => UUID.new.generate,
-          :port                       => DEFAULT_CONNECTION_PORT,
-          :origin                     => DEFAULT_ORIGIN,
-          :subscribe_timeout          => DEFAULT_SUBSCRIBE_TIMEOUT,
-          :timeout                    => DEFAULT_NON_SUBSCRIBE_TIMEOUT,
-          :max_retries                => MAX_RETRIES,
-          :retries_interval           => RETRIES_INTERVAL,
-          :non_subscribe_timeout      => DEFAULT_NON_SUBSCRIBE_TIMEOUT,
-          :reconnect_max_attempts     => DEFAULT_RECONNECT_ATTEMPTS,
-          :reconnect_retry_interval   => DEFAULT_RECONNECT_INTERVAL,
-          :reconnect_response_timeout => DEFAULT_RECONNECT_RESPONSE_TIMEOUT,
-          :ttl                        => DEFAULT_TTL,
-          :secret_key                 => 0
-      }
-
-      # Let's fill missing keys with default values
-      Pubnub.logger.debug(:pubnub){'Setting default values'}
-      defaults.each do |key,default_value|
-        env[key] = default_value if @env[key].nil?
-      end
+    def generate_uuid
+      @env[:uuid] = UUID.generate
+    end
 
-      env
+    def assign_defaults
+      default_values.each do |k, v|
+        @env[k] = v unless @env[k]
+      end
+      @env[:timetoken] = 0
     end
 
     def symbolize_options_keys(options)
-      Pubnub.logger.debug(:pubnub){'Symbolizing options keys'}
       symbolized_options = {}
-      options.each_key { |k| symbolized_options.merge!({ k.to_sym => options[k] }) }
+      options.each_key do |k|
+        symbolized_options.merge!(k.to_sym => options[k])
+      end
       symbolized_options
     end
-
-    def classify_method(method)
-      method.split('_').map{ |w| w.capitalize }.join
-    end
-
-    def validate!(parameters)
-      raise InitializationError.new(:object => self, :message => 'Origin parameter is not valid. Should be type of String')                  unless parameters[:origin].is_a?(String) || parameters[:origin].blank?
-      raise InitializationError.new(:object => self, :message => 'Missing required :subscribe_key parameter')                                unless parameters[:subscribe_key]
-      raise InitializationError.new(:object => self, :message => 'Subscribe key parameter is not valid. Should be type of String or Symbol') unless [String, Symbol].include?(parameters[:subscribe_key].class)
-      raise InitializationError.new(:object => self, :message => 'Publish key parameter is not valid. Should be type of String or Symbol')   unless [String, Symbol].include?(parameters[:publish_key].class) || parameters[:publish_key].blank?
-    end
-
   end
 end