pubnub 4.6.2 → 5.0.0

data/lib/pubnub/client/paged_history.rb

@@ -1,19 +1,46 @@
+# frozen_string_literal: true
+
 # Toplevel Pubnub module.
 module Pubnub
   # Pubnub client Class
   class Client
     # Module that holds paged_history event logic
     module PagedHistory
+      # Fetch messages as long as one of criteria won't be met.
+      # Messages returned as single envelope.
+      def all_history_messages(options = {}, &block)
+        channel = options.fetch(:channel)
+        # Time frame between which messages should be fetched.
+        start_tt = options.fetch(:start, nil)
+        end_tt = options.fetch(:end, nil)
+        page_size = options.fetch(:page_size, 100)          # How many messages per-request should be fetched.
+        reverse = options.fetch(:reverse, false)            # Order in which messages should be retrieved if :end not set.
+        include_token = options.fetch(:include_token, true) # Whether timetoken should be included with message or not.
+        maximum = options.fetch(:max, 500)                  # Maximum number of messages which should be fetched.
+        callback = options.fetch(:callback, block)
+
+        reverse = false unless end_tt.nil? # Disable revers if closed time interval specified.
+        maximum = nil unless end_tt.nil? # Disable maximum messages count if closed time interval specified.
+
+        if options[:http_sync]
+          sync_all_history_messages(channel, include_token, page_size, reverse, maximum, callback, start: start_tt, end: end_tt)
+        else
+          async_all_history_messages(options)
+        end
+      end
+
       def paged_history(options = {}, &block)
         channel = options.fetch(:channel)
-        page = options.fetch(:page, 1)
-        limit = options.fetch(:limit, 100)
+        page = options.fetch(:page, 1)                      # How many mages should be fetched with specified limit.
+        limit = options.fetch(:limit, 100)                  # How many messages per page should be fetched.
+        include_token = options.fetch(:include_token, false) # Whether timetoken should be included with message or not.
         callback = options.fetch(:callback, block)
-        sync = options[:http_sync]
-        start_tt = options.fetch(:start)
-        end_tt = options.fetch(:end)
-      if sync
-          sync_paged_history(channel, page, limit, callback, start: start_tt, end: end_tt)
+        # Time frame between which messages should be fetched.
+        start_tt = options.fetch(:start, nil)
+        end_tt = options.fetch(:end, nil)
+
+        if options[:http_sync]
+          sync_paged_history(channel, page, limit, include_token, callback, start: start_tt, end: end_tt)
         else
           async_paged_history(options)
         end
@@ -21,40 +48,140 @@ module Pubnub
 
       private
 
-      def sync_paged_history(channel, page, limit, callback, timetokens)
+      def sync_all_history_messages(channel, include_token, page_size, reverse, maximum, callback, timetokens)
+        next_timetoken = timetokens[:start]
+        messages_timetokens = timetokens.dup
+        final_envelope = nil
+        keep_fetching = true
+        messages = []
+
+        while keep_fetching
+          envelope = history(
+            channel: channel,
+            include_token: include_token,
+            count: page_size,
+            reverse: reverse,
+            start: next_timetoken,
+            end: timetokens[:end],
+            http_sync: true
+          )
+
+          # Terminate fetch because last attempt failed.
+          if envelope.status[:category] != :ack
+            final_envelope = envelope
+            break
+          end
+
+          result_data = envelope.result[:data]
+          result_messages = result_data[:messages]
+          break if result_messages.empty?
+
+          if reverse || timetokens[:end]
+            messages_timetokens[:start] = result_data[:start].to_i if messages.empty?
+            messages_timetokens[:end] = result_data[:end].to_i
+            messages.concat(result_messages)
+          else
+            messages_timetokens[:end] = result_data[:end].to_i if messages.empty?
+            messages_timetokens[:start] = result_data[:start].to_i
+            messages.unshift(*result_messages)
+          end
+
+          keep_fetching = result_messages.length == page_size
+          keep_fetching = messages.length < maximum if keep_fetching && maximum && maximum > 0
+
+          if keep_fetching
+            next_timetoken = reverse ? result_data[:end].to_i : result_data[:start].to_i
+            next_timetoken = result_data[:end].to_i unless timetokens[:end].nil?
+          end
+        end
+
+        # Create envelop if no error should be reported.
+        final_envelope = envelope_with_messages(messages, messages_timetokens) if final_envelope.nil?
+
+        callback&.call final_envelope
+        final_envelope
+      end
+
+      # Retrieve results page-by-page (callback called for each page).
+      def sync_paged_history(channel, page, limit, include_token, callback, timetokens)
         envelopes = []
-        page.times do |i|
-          envelopes << history(
+        page.times do |_i|
+          envelope = history(
             channel: channel,
+            include_token: include_token,
             http_sync: true,
             count: limit,
             start: timetokens[:start],
             end: timetokens[:end]
           )
-          envelopes.flatten!
-          timetokens[:end] = envelopes.last.history_start.to_i
-          envelopes = [] unless i == page - 1
+
+          break if envelope.result[:data][:messages].empty?
+
+          envelopes.push envelope
+          timetokens[:start] = envelope.result[:data][:start].to_i
+          # No need to iterate further if there is no more messages.
+          break if envelope.result[:data][:messages].length < limit
         end
 
         call_callback(envelopes, callback)
       end
 
       def async_paged_history(options)
-        Concurrent::Future.new do
+        Concurrent::Future.execute do
           sync_options = options.dup
           sync_options[:http_sync] = true
-          paged_history(sync_options, &block)
+          paged_history(sync_options)
+        end
+      end
+
+      def async_all_history_messages(options)
+        Concurrent::Future.execute do
+          sync_options = options.dup
+          sync_options[:http_sync] = true
+          all_history_messages(sync_options)
         end
       end
 
       def call_callback(envelopes, callback)
-        envelopes.flatten!
         if callback
           envelopes.each do |envelope|
-            secure_call callback, envelope
+            callback.call envelope
           end
         end
         envelopes
+      rescue StandardError => e
+        Pubnub.logger.error('Pubnub::Client') { "Error while calling callback #{e.inspect}" }
+      end
+
+      def envelope_with_messages(messages, timetokens)
+        Pubnub::Envelope.new(
+          event: :history,
+          event_options: nil,
+          timetoken: nil,
+          status: {
+            code: 200,
+            client_request: nil,
+            server_response: nil,
+
+            category: Pubnub::Constants::STATUS_ACK,
+            error: false,
+            auto_retried: false,
+
+            data: nil,
+            current_timetoken: nil,
+            last_timetoken: nil,
+            subscribed_channels: nil,
+            subscribed_channel_groups: nil,
+            config: nil
+          },
+          result: {
+            code: 200,
+            operation: Pubnub::Constants::OPERATION_HISTORY,
+            client_request: nil,
+            server_response: nil,
+            data: { messages: messages, end: timetokens[:end], start: timetokens[:start] }
+          }
+        )
       end
     end
   end

data/lib/pubnub/client.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 require 'pubnub/error'
 require 'pubnub/uuid'
 require 'pubnub/formatter'
@@ -34,6 +36,8 @@ require 'pubnub/validators/client'
 require 'pubnub/validators/audit'
 require 'pubnub/validators/channel_registration'
 require 'pubnub/validators/grant'
+require 'pubnub/validators/grant_token'
+require 'pubnub/validators/revoke_token'
 require 'pubnub/validators/heartbeat'
 require 'pubnub/validators/here_now'
 require 'pubnub/validators/history'
@@ -67,6 +71,7 @@ require 'pubnub/validators/set_channel_members'
 require 'pubnub/validators/set_memberships'
 require 'pubnub/validators/remove_channel_members'
 require 'pubnub/validators/remove_memberships'
+require 'pubnub/cbor'
 
 Dir[File.join(File.dirname(__dir__), 'pubnub', 'events', '*.rb')].each do |file|
   require file
@@ -319,6 +324,15 @@ module Pubnub
       @telemetry.await.fetch_average(event).value
     end
 
+    def parse_token(token)
+      token_bytes = Base64.urlsafe_decode64(token)
+      Cbor.new.decode(token_bytes.bytes)
+    end
+
+    def set_token(token)
+      @env[:token] = token
+    end
+
     private
 
     def create_state_pools(event)
@@ -370,14 +384,9 @@ module Pubnub
 
     def prepare_env
       assign_defaults
-      generate_uuid if @env[:uuid].blank?
       setup_pools
     end
 
-    def generate_uuid
-      @env[:uuid] = UUID.generate
-    end
-
     def assign_defaults
       @env[:origin] = @env[:origins_pool].first if @env[:origins_pool]
       default_values.each do |k, v|

data/lib/pubnub/constants.rb

@@ -57,6 +57,8 @@ module Pubnub
     OPERATION_CHANNEL_GROUP_REMOVE = :channel_group_remove
     OPERATION_AUDIT = :audit
     OPERATION_GRANT = :grant
+    OPERATION_GRANT_TOKEN = :grant_token
+    OPERATION_REVOKE_TOKEN = :revoke_token
     OPERATION_REVOKE = :revoke
     OPERATION_DELETE = :delete
     OPERATION_LIST_ALL_CHANNEL_GROUPS = :list_all_channel_groups
@@ -86,13 +88,14 @@ module Pubnub
       OPERATION_SUBSCRIBE, OPERATION_HEARTBEAT, OPERATION_PRESENCE, OPERATION_TIME, OPERATION_HISTORY,
       OPERATION_HERE_NOW, OPERATION_GLOBAL_HERE_NOW, OPERATION_GET_STATE, OPERATION_LIST_ALL_CHANNEL_GROUPS,
       OPERATION_LIST_ALL_CHANNELS_IN_CHANNEL_GROUP, OPERATION_CHANNEL_GROUP_ADD, OPERATION_CHANNEL_GROUP_REMOVE,
-      OPERATION_AUDIT, OPERATION_GRANT, OPERATION_REVOKE, OPERATION_WHERE_NOW, OPERATION_MESSAGE_COUNTS,
-      OPERATION_ADD_CHANNELS_TO_PUSH, OPERATION_LIST_PUSH_PROVISIONS, OPERATION_REMOVE_CHANNELS_FROM_PUSH,
-      OPERATION_REMOVE_DEVICE_FROM_PUSH, OPERATION_SIGNAL, OPERATION_SET_UUID_METADATA, OPERATION_GET_UUID_METADATA,
-      OPERATION_GET_ALL_UUID_METADATA, OPERATION_REMOVE_UUID_METADATA, OPERATION_SET_CHANNEL_METADATA,
-      OPERATION_GET_CHANNEL_METADATA, OPERATION_GET_ALL_CHANNELS_METADATA, OPERATION_REMOVE_CHANNEL_METADATA,
-      OPERATION_GET_CHANNEL_MEMBERS, OPERATION_SET_CHANNEL_MEMBERS, OPERATION_REMOVE_CHANNEL_MEMBERS,
-      OPERATION_GET_MEMBERSHIPS, OPERATION_SET_MEMBERSHIPS, OPERATION_REMOVE_MEMBERSHIPS
+      OPERATION_AUDIT, OPERATION_GRANT, OPERATION_GRANT_TOKEN, OPERATION_REVOKE, OPERATION_WHERE_NOW,
+      OPERATION_MESSAGE_COUNTS, OPERATION_ADD_CHANNELS_TO_PUSH, OPERATION_LIST_PUSH_PROVISIONS,
+      OPERATION_REMOVE_CHANNELS_FROM_PUSH, OPERATION_REMOVE_DEVICE_FROM_PUSH, OPERATION_SIGNAL,
+      OPERATION_SET_UUID_METADATA, OPERATION_GET_UUID_METADATA, OPERATION_GET_ALL_UUID_METADATA,
+      OPERATION_REMOVE_UUID_METADATA, OPERATION_SET_CHANNEL_METADATA, OPERATION_GET_CHANNEL_METADATA,
+      OPERATION_GET_ALL_CHANNELS_METADATA, OPERATION_REMOVE_CHANNEL_METADATA, OPERATION_GET_CHANNEL_MEMBERS,
+      OPERATION_SET_CHANNEL_MEMBERS, OPERATION_REMOVE_CHANNEL_MEMBERS, OPERATION_GET_MEMBERSHIPS,
+      OPERATION_SET_MEMBERSHIPS, OPERATION_REMOVE_MEMBERSHIPS
     ].freeze
 
     # Announcements

data/lib/pubnub/event.rb

@@ -24,8 +24,8 @@ module Pubnub
       env.delete(:state)
       create_variables_from_options(env.merge(options))
       @origin = @app.current_origin
-      format_channels
-      format_group
+      format_channels if enable_format_channels?
+      format_group if enable_format_group?
       set_timestamp
       validate!
       telemetry = @app.telemetry_for(@telemetry_name)
@@ -44,7 +44,7 @@ module Pubnub
       envelopes
     end
 
-    def send_request(compressed_body = '')
+    def send_request(compressed_body = '', header = {})
       Pubnub.logger.debug('Pubnub::Event') { '#send_request called' }
 
       @compressed_body = compressed_body
@@ -54,13 +54,13 @@ module Pubnub
       telemetry_time_start = ::Time.now.to_f
       response = case operation_http_method
                  when "get"
-                   sender.get(uri.to_s)
+                   sender.get(uri.to_s, header: header)
                  when "post"
-                   sender.post(uri.to_s, body: compressed_body)
+                   sender.post(uri.to_s, body: compressed_body, header: header)
                  when "patch"
-                   sender.patch(uri.to_s, body: compressed_body)
+                   sender.patch(uri.to_s, body: compressed_body, header: header)
                  else
-                   sender.delete(uri.to_s)
+                   sender.delete(uri.to_s, header: header)
                  end
 
       begin
@@ -102,9 +102,18 @@ module Pubnub
 
     private
 
+    def enable_format_channels?
+      true
+    end
+
+    def enable_format_group?
+      true
+    end
+
     def operation_http_method
       case @event
-      when Pubnub::Constants::OPERATION_DELETE, Pubnub::Constants::OPERATION_REMOVE_CHANNEL_METADATA, Pubnub::Constants::OPERATION_REMOVE_UUID_METADATA
+      when Pubnub::Constants::OPERATION_DELETE, Pubnub::Constants::OPERATION_REMOVE_CHANNEL_METADATA,
+           Pubnub::Constants::OPERATION_REMOVE_UUID_METADATA, Pubnub::Constants::OPERATION_REVOKE_TOKEN
         "delete"
       when Pubnub::Constants::OPERATION_SET_UUID_METADATA, Pubnub::Constants::OPERATION_SET_CHANNEL_METADATA,
            Pubnub::Constants::OPERATION_SET_CHANNEL_MEMBERS, Pubnub::Constants::OPERATION_SET_MEMBERSHIPS,
@@ -136,8 +145,9 @@ module Pubnub
         pnsdk: @app.sdk_version
       }
 
+      token = @app.env[:token]
       empty_if_blank = {
-        auth: @auth_key,
+        auth: token ? token : @auth_key,
         uuid: @app.env[:uuid],
         @telemetry_name => @current_telemetry
       }
@@ -164,7 +174,8 @@ module Pubnub
                      end count limit reverse presence_callback store skip_validate
                      state channel_group channel_groups compressed meta customs include_token
                      replicate with_presence cipher_key_selector include_meta join update get
-                     add remove push_token push_gateway environment topic
+                     add remove push_token push_gateway environment topic authorized_uuid
+                     token
                    ]
 
       options = options.each_with_object({}) { |option, obj| obj[option.first.to_sym] = option.last }

data/lib/pubnub/events/grant_token.rb

@@ -0,0 +1,172 @@
+module Pubnub
+  # Holds grant token functionality
+  class GrantToken < SingleEvent
+    include Concurrent::Async
+    include Pubnub::Validator::GrantToken
+
+    def initialize(options, app)
+      @event = current_operation
+      @telemetry_name = :l_pamv3
+      @uuids = options[:uuids] || {}
+      options[:channels] = options[:channels] || {}
+      options[:channel_groups] = options[:channel_groups] || {}
+      super
+    end
+
+    def fire
+      Pubnub.logger.debug('Pubnub::GrantToken') { "Fired event #{self.class}" }
+
+      raw_body = {
+        ttl: @ttl,
+        permissions: {
+          meta: @meta,
+          uuid: @authorized_uuid,
+          resources: prepare_permissions(:resource, @channels, @channel_groups, @uuids),
+          patterns: prepare_permissions(:pattern, @channels, @channel_groups, @uuids)
+        }.select { |_, v| v }
+      }
+      body = Formatter.format_message(raw_body, "", false, false)
+      response = send_request(body, { "Content-Type": "application/json" })
+
+      envelopes = fire_callbacks(handle(response, uri))
+      finalize_event(envelopes)
+      envelopes
+    end
+
+    private
+
+    def enable_format_channels?
+      false
+    end
+
+    def enable_format_group?
+      false
+    end
+
+    def current_operation
+      Pubnub::Constants::OPERATION_GRANT_TOKEN
+    end
+
+    def prepare_permissions(type, channels, groups, uuids)
+      {
+        channels: prepare_single_permissions(type, channels),
+        groups: prepare_single_permissions(type, groups),
+        uuids: prepare_single_permissions(type, uuids)
+      }
+    end
+
+    def prepare_single_permissions(type, resources)
+      resources
+        .select { |_, v| v.type == type }
+        .to_h { |k, v| [k, v.calculate_bitmask] }
+    end
+
+    def valid_envelope(parsed_response, req_res_objects)
+      Pubnub::Envelope.new(
+        event: @event,
+        event_options: @given_options,
+        timetoken: nil,
+        status: {
+          code: req_res_objects[:response].code,
+          client_request: req_res_objects[:request],
+          server_response: req_res_objects[:response],
+          category: Pubnub::Constants::STATUS_ACK,
+          error: false,
+          auto_retried: false,
+
+          current_timetoken: nil,
+          last_timetoken: nil,
+          subscribed_channels: nil,
+          subscribed_channel_groups: nil,
+
+          data: nil,
+
+          config: get_config
+
+        },
+        result: {
+          code: req_res_objects[:response].code,
+          operation: current_operation,
+          client_request: req_res_objects[:request],
+          server_response: req_res_objects[:response],
+
+          data: parsed_response['data']
+        }
+      )
+    end
+
+    def path
+      '/' + [
+        'v3',
+        'pam',
+        @subscribe_key,
+        'grant'
+      ].join('/')
+    end
+  end
+
+  class Permissions
+    attr_reader :type
+
+    class << Permissions
+      def pat(read: false, write: false, manage: false, delete: false,
+              create: false, get: false, update: false, join: false)
+        Permissions.new(
+          type: :pattern,
+          read: read,
+          write: write,
+          manage: manage,
+          delete: delete,
+          create: create,
+          get: get,
+          update: update,
+          join: join
+        )
+      end
+
+      def res(read: false, write: false, manage: false, delete: false, create: false, get: false, update: false, join: false)
+        Permissions.new(
+          type: :resource,
+          read: read,
+          write: write,
+          manage: manage,
+          delete: delete,
+          create: create,
+          get: get,
+          update: update,
+          join: join
+        )
+      end
+    end
+
+    def initialize(options)
+      @type = options[:type]
+      @read = options[:read] || false
+      @write = options[:write] || false
+      @manage = options[:manage] || false
+      @delete = options[:delete] || false
+      @create = options[:create] || false
+      @get = options[:get] || false
+      @update = options[:update] || false
+      @join = options[:join] || false
+    end
+
+    def to_s
+      "Permissions: {:read => #{@read}, :write => #{@write}, :manage => #{@manage} , :delete => #{@delete}, :create => #{@create}, :get => #{@get}, :update => #{@update}, :join => #{@join}}"
+    end
+
+    def calculate_bitmask
+      sum = 0
+
+      sum |= 1 if @read
+      sum |= 2 if @write
+      sum |= 4 if @manage
+      sum |= 8 if @delete
+      sum |= 16 if @create
+      sum |= 32 if @get
+      sum |= 64 if @update
+      sum |= 128 if @join
+      sum
+    end
+  end
+end

data/lib/pubnub/events/revoke_token.rb

@@ -0,0 +1,66 @@
+module Pubnub
+  # Holds revoke token functionality
+  class RevokeToken < SingleEvent
+    include Concurrent::Async
+    include Pubnub::Validator::RevokeToken
+
+    def initialize(options, app)
+      @event = :revoke_token
+      super
+      @token = @token.split(' ')
+            .map{ |part| CGI.escape(part) }
+            .join("%20")
+    end
+
+    private
+
+    def current_operation
+      Pubnub::Constants::OPERATION_GRANT_TOKEN
+    end
+
+    def valid_envelope(parsed_response, req_res_objects)
+      Pubnub::Envelope.new(
+        event: @event,
+        event_options: @given_options,
+        timetoken: nil,
+        status: {
+          code: req_res_objects[:response].code,
+          client_request: req_res_objects[:request],
+          server_response: req_res_objects[:response],
+          category: Pubnub::Constants::STATUS_ACK,
+          error: false,
+          auto_retried: false,
+
+          current_timetoken: nil,
+          last_timetoken: nil,
+          subscribed_channels: nil,
+          subscribed_channel_groups: nil,
+
+          data: nil,
+
+          config: get_config
+
+        },
+        result: {
+          code: req_res_objects[:response].code,
+          operation: current_operation,
+          client_request: req_res_objects[:request],
+          server_response: req_res_objects[:response],
+
+          data: parsed_response['data']
+        }
+      )
+    end
+
+
+    def path
+      '/' + [
+        'v3',
+        'pam',
+        @subscribe_key,
+        'grant',
+        @token
+      ].join('/')
+    end
+  end
+end

data/lib/pubnub/validators/client.rb

@@ -11,6 +11,7 @@ module Pubnub
           validate_origin parameters[:origin], true
           validate_subscribe_key parameters[:subscribe_key], true
           validate_publish_key parameters[:publish_key]
+          validate_uuid parameters[:uuid]
         end
       end
     end

data/lib/pubnub/validators/common_validator.rb

@@ -52,6 +52,23 @@ module Pubnub
           )
         end
       end
+
+      # Validates given uuid
+      def validate_uuid(uuid)
+        if !uuid || uuid.blank?
+          raise(
+            InitializationError.new,
+            'Missing required :uuid parameter.'
+          )
+        elsif !([String, Symbol].include?(uuid.class) ||
+          uuid.blank?)
+          raise(
+            InitializationError.new,
+            'UUID parameter is not valid. \
+                   Should be type of String or Symbol.'
+          )
+        end
+      end
     end
   end
 end

data/lib/pubnub/validators/grant_token.rb

@@ -0,0 +1,51 @@
+# Toplevel Pubnub module.
+module Pubnub
+  # Validator module that holds all validators modules
+  module Validator
+    # Validator for Grant event
+    module GrantToken
+      include CommonValidator
+
+      def validate!
+        validate_keys!
+        validate_ttl!
+        validate_permissions!(@uuids, ":uuids")
+        validate_permissions!(@channels, ":channels")
+        validate_permissions!(@channel_groups, ":uuids")
+      end
+
+      private
+
+      def validate_keys!
+        raise(
+          ArgumentError.new(object: self, message: ':subscribe_key is required for grant token event.'),
+          ':subscribe_key is required for grant token event.'
+        ) if @subscribe_key.nil? || @subscribe_key.empty?
+
+        raise(
+          ArgumentError.new(object: self, message: ':secret_key is required for grant token event.'),
+          ':publish_key is required for grant token event.'
+        ) if @secret_key.nil? || @secret_key.empty?
+      end
+
+      def validate_ttl!
+        return unless !@ttl.nil? && !@ttl.is_a?(Integer)
+
+        raise(
+          ArgumentError.new(object: self, message: ':ttl has to be kind of Integer for grant token event.'),
+          ':ttl has to be kind of Integer for grant token event.'
+        )
+      end
+
+      def validate_permissions!(arg, name)
+        return if arg.nil?
+
+        raise(
+          ArgumentError.new(object: self, message: ":#{name} has to be kind of Hash for grant token event."),
+          ":#{name} has to be kind of Hash for grant token event."
+        ) unless arg.is_a?(Hash)
+      end
+    end
+  end
+end
+