pubnub 4.6.1 → 4.8.0

data/features/support/env.rb

@@ -0,0 +1,15 @@
+ParameterType(
+  name:        'resourceType',
+  regexp:      /CHANNEL|CHANNEL_GROUP|UUID/,
+  type:        String,
+  transformer: ->(s) { s }
+)
+
+ParameterType(
+  name:        'permissionType',
+  regexp:      /READ|WRITE|GET|MANAGE|UPDATE|JOIN|DELETE|/,
+  type:        String,
+  transformer: ->(s) { s }
+)
+
+

data/features/support/helper.rb

@@ -0,0 +1,39 @@
+def has_permission(perms, permission_type)
+  current_perm = nil
+  eval "current_perm = Pubnub::Permissions.res(#{permission_type.downcase}: true).calculate_bitmask"
+  perms & current_perm != 0
+end
+
+def prepare_permissions_map(grants, resource_type)
+  grants
+    .select { |_, value|
+      value[:resource_type] == resource_type
+    }
+    .to_h { |name, value|
+      empty_permissions = if value[:pattern]
+                            Pubnub::Permissions.pat
+                          else
+                            Pubnub::Permissions.res
+                          end
+      permissions = value[:permission_type].reduce(empty_permissions) { |accumulated_permissions, string_perm|
+        accumulated_permissions.instance_variable_set("@" + string_perm.downcase, true)
+        accumulated_permissions
+      }
+      [name, permissions]
+    }
+end
+
+def call_grant_token(pubnub, grant_token_state)
+  pubnub.grant_token(
+    ttl: grant_token_state[:ttl],
+    http_sync: true,
+    channels: prepare_permissions_map(grant_token_state[:current_grant], "CHANNEL"),
+    channel_groups: prepare_permissions_map(grant_token_state[:current_grant], "CHANNEL_GROUP"),
+    uuids: prepare_permissions_map(grant_token_state[:current_grant], "UUID"),
+    authorized_uuid: grant_token_state[:authorized_uuid]
+  )
+end
+
+def parse_error_body(error_response)
+  Pubnub::Formatter.parse_json(error_response.status[:server_response].body)[0]
+end

data/features/support/hooks.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+require 'json'
+
+Before do |scenario|
+  @grant_token_state = {}
+  @global_state = {}
+  @grant_token_state[:current_grant] = {}
+  @pn_configuration = {}
+
+  when_mock_server_used {
+    puts "Using mock"
+    expect(ENV['SERVER_HOST']).not_to be_nil
+    expect(ENV['SERVER_PORT']).not_to be_nil
+    @pn_configuration = {
+      origin: ENV['SERVER_HOST'] + ":" + ENV['SERVER_PORT'],
+      isSecure: false,
+    }
+  }
+
+  when_mock_server_used {
+    init_mock(scenario)
+  }
+end
+
+After do |scenario|
+  when_mock_server_used {
+    expect_mock(scenario)
+  }
+end
+
+def when_mock_server_used(&block)
+  if ENV['SERVER_MOCK']&.to_s&.downcase == 'true'
+    block.call
+  end
+end
+
+def init_mock(scenario)
+  contract_name = contract_name(scenario)
+  if contract_name
+    call_init_endpoint(contract_name)
+  end
+end
+
+def call_init_endpoint(contract_name)
+  Net::HTTP.get_response("#{ENV['SERVER_HOST']}", "/init?__contract__script__=#{contract_name}", "#{ENV['SERVER_PORT']}")
+end
+
+def expect_mock(scenario)
+  contract_name = contract_name(scenario)
+  if contract_name
+    expect_result = call_expect_endpoint()
+    print(expect_result)
+    if still_pending?(expect_result) || some_failed?(expect_result)
+      message = "Scenario #{extract_contract(expect_result)} considered failure:
+pending - #{extract_pending(expect_result)},
+failed - #{extract_failed(expect_result)}"
+      RSpec::Expectations.fail_with(message)
+    end
+  end
+end
+
+def extract_contract(expect_result)
+  expect_result['contract']
+end
+
+def extract_pending(expect_result)
+  expect_result['expectations']['pending'].join(", ")
+end
+
+def extract_failed(expect_result)
+  expect_result['expectations']['failed'].join(", ")
+end
+
+def still_pending?(expect_result)
+  pending = expect_result['expectations']['pending']
+  not pending.empty?
+end
+
+def some_failed?(expect_result)
+  pending = expect_result['expectations']['failed']
+  not pending.empty?
+end
+
+def call_expect_endpoint
+  expect_response = Net::HTTP.get_response("#{ENV['SERVER_HOST']}", "/expect", "#{ENV['SERVER_PORT']}")
+
+  if expect_response == nil || expect_response.body == nil
+    RSpec::Expectations.fail_with("Expect response body is null")
+  else
+    JSON.parse(expect_response.body)
+  end
+end
+
+def contract_name(scenario)
+  scenario.source_tag_names&.
+    select { |tagName| tagName.start_with?("@contract") }&.
+    map { |tagName| tagName.split("=")[1] }&.first
+end

data/lib/pubnub/cbor.rb

@@ -0,0 +1,182 @@
+module Pubnub
+  class Cbor
+
+    private
+
+    TYPE_MASK = 0b11100000
+    ADDITIONAL_MASK = 0b00011111
+
+    TYPE_UNSIGNED_INT = 0b00000000
+    TYPE_NEGATIVE_INT = 0b00100000
+    TYPE_BYTE_STRING = 0b01000000
+    TYPE_TEXT_STRING = 0b01100000
+    TYPE_ARRAY = 0b10000000
+    TYPE_HASHMAP = 0b10100000
+    TYPE_TAG = 0b11000000
+    TYPE_FLOAT = 0b11100000
+
+    ADDITIONAL_TYPE_INDEFINITE = 31
+    INDEFINITE_BREAK = 0b11111111
+
+    ADDITIONAL_LENGTH_1B = 24
+    ADDITIONAL_LENGTH_2B = 25
+    ADDITIONAL_LENGTH_4B = 26
+    ADDITIONAL_LENGTH_8B = 27
+
+    ADDITIONAL_LENGTH_BYTES = {
+      ADDITIONAL_LENGTH_1B => 1,
+      ADDITIONAL_LENGTH_2B => 2,
+      ADDITIONAL_LENGTH_4B => 4,
+      ADDITIONAL_LENGTH_8B => 8,
+    }
+
+    SIMPLE_VALUE_FALSE = 0xF4
+    SIMPLE_VALUE_TRUE = 0xF5
+    SIMPLE_VALUE_NULL = 0xF6
+    SIMPLE_VALUE_UNDEF = 0xF7
+
+    def bytearray_to_i(byte_array)
+      byte_array.reverse_each.map.with_index do |b, i|
+        b << 8 * i
+      end.reduce(0) do |reduced, byte|
+        reduced | byte
+      end
+    end
+
+    def decode_integer(data, additional)
+      if ADDITIONAL_LENGTH_BYTES.member?(additional)
+        bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+      else
+        additional
+      end
+    end
+
+    def decode_float(data, additional)
+      if additional <= 23
+        additional
+      else
+        bytes = bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+        case (additional)
+        when ADDITIONAL_LENGTH_1B
+          bytes
+        when ADDITIONAL_LENGTH_2B
+          sign = (bytes >> 15) != 0 ? -1 : 1
+          exp = (bytes & 0b0111110000000000) >> 10
+          mant = bytes & 0b1111111111
+          if exp == 0
+            result = (2 ** -14) * (mant / 1024.to_f)
+          elsif exp == 0b11111
+            result = Float::INFINITY
+          else
+            result = (2 ** (exp - 15)) * (1 + mant / 1024.to_f)
+          end
+          sign * result
+        when ADDITIONAL_LENGTH_4B
+          sign = (bytes >> 31) != 0 ? -1 : 1
+          x = (bytes & ((1 << 23) - 1)) + (1 << 23)
+          exp = (bytes >> 23 & 0xFF) - 127
+          x * (2 ** (exp - 23)) * sign
+        when ADDITIONAL_LENGTH_8B
+          sign = (bytes >> 63) != 0 ? -1 : 1
+          exp = (bytes >> 52) & 0x7FF
+
+          mant = bytes & 0xFFFFFFFFFFFFF
+
+          if 0 == exp
+            val = mant * 2 ** (-(1022 + 52))
+          elsif 0b11111111111 != exp
+            val = (mant + (1 << 52)) * 2 ** (exp - (1023 + 52))
+          else
+            val = 0 == mant ? Float::INFINITY : Float::NAN
+          end
+          sign * val
+        end
+      end
+    end
+
+    def indefinite_data(data)
+      result = []
+
+      loop do
+        byte = data.shift
+        break if byte == INDEFINITE_BREAK
+        result.append(byte)
+        break if data.empty?
+      end
+      result
+    end
+
+    def compute_length(data, additional)
+      if ADDITIONAL_LENGTH_BYTES.member?(additional)
+        bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+      else
+        additional
+      end
+    end
+
+    def decode_string(data, additional)
+      if additional == ADDITIONAL_TYPE_INDEFINITE
+        indefinite_data(data).pack('C*').force_encoding('UTF-8')
+      else
+        length = compute_length(data, additional)
+        data.shift(length).pack('C*').force_encoding('UTF-8')
+      end
+    end
+
+    def decode_map(data, additional)
+      length = compute_length(data, additional)
+      result = Hash.new
+      (1..length).each { result.store(parse_data(data), parse_data(data)) }
+      result
+    end
+
+    def decode_array(data, additional)
+      length = compute_length(data, additional)
+      (1..length).map { parse_data(data) }
+    end
+
+    def parse_data(data)
+      byte = data.shift
+
+      case (byte)
+      when SIMPLE_VALUE_NULL
+        return nil
+      when SIMPLE_VALUE_TRUE
+        return true
+      when SIMPLE_VALUE_FALSE
+        return false
+      when SIMPLE_VALUE_UNDEF
+        return nil
+      else
+        type = byte & TYPE_MASK
+        additional = byte & ADDITIONAL_MASK
+
+        case (type)
+        when TYPE_NEGATIVE_INT
+          -1 - decode_integer(data, additional)
+        when TYPE_UNSIGNED_INT
+          decode_integer(data, additional)
+        when TYPE_FLOAT
+          decode_float(data, additional).to_f
+        when TYPE_BYTE_STRING
+          decode_string(data, additional)
+        when TYPE_TEXT_STRING
+          decode_string(data, additional)
+        when TYPE_ARRAY
+          decode_array(data, additional)
+        when TYPE_HASHMAP
+          decode_map(data, additional)
+        else
+          nil
+        end
+      end
+    end
+
+    public
+
+    def decode(value)
+      parse_data(value)
+    end
+  end
+
+end

data/lib/pubnub/client/events.rb

@@ -4,7 +4,7 @@ module Pubnub
   class Client
     # Module that holds generator for all events
     module Events
-      EVENTS = %w[publish subscribe presence leave history here_now audit grant delete_messages
+      EVENTS = %w[publish subscribe presence leave history here_now audit grant grant_token revoke_token delete_messages
                   revoke time heartbeat where_now set_state state channel_registration message_counts signal
                   add_channels_to_push list_push_provisions remove_channels_from_push remove_device_from_push
                   set_uuid_metadata set_channel_metadata remove_uuid_metadata remove_channel_metadata

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)

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