sockudo 1.0.0 → 2.0.0

data/lib/sockudo/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'securerandom'
 require 'pusher-signature'
@@ -14,7 +16,7 @@ module Sockudo
     DEFAULT_SEND_TIMEOUT = 5
     DEFAULT_RECEIVE_TIMEOUT = 5
     DEFAULT_KEEP_ALIVE_TIMEOUT = 30
-    DEFAULT_CLUSTER = "mt1"
+    DEFAULT_CLUSTER = 'mt1'
 
     # Loads the configuration from an url in the environment
     def self.from_env(key = 'SOCKUDO_URL')
@@ -30,15 +32,15 @@ module Sockudo
     end
 
     def initialize(options = {})
-      @scheme = "https"
+      @scheme = 'https'
       @port = options[:port] || 443
 
       if options.key?(:encrypted)
-        warn "[DEPRECATION] `encrypted` is deprecated and will be removed in the next major version. Use `use_tls` instead."
+        warn '[DEPRECATION] `encrypted` is deprecated and will be removed in the next major version. Use `use_tls` instead.'
       end
 
       if options[:use_tls] == false || options[:encrypted] == false
-        @scheme = "http"
+        @scheme = 'http'
         @port = options[:port] || 80
       end
 
@@ -69,18 +71,20 @@ module Sockudo
     def authentication_token
       raise ConfigurationError, :key unless @key
       raise ConfigurationError, :secret unless @secret
-      Sockudo::Signature::Token.new(@key, @secret)
+
+      Pusher::Signature::Token.new(@key, @secret)
     end
 
     # @private Builds a url for this app, optionally appending a path
     def url(path = nil)
       raise ConfigurationError, :app_id unless @app_id
+
       URI::Generic.build({
-        scheme: @scheme,
-        host: @host,
-        port: @port,
-        path: "/apps/#{@app_id}#{path}"
-      })
+                           scheme: @scheme,
+                           host: @host,
+                           port: @port,
+                           path: "/apps/#{@app_id}#{path}"
+                         })
     end
 
     # Configure Sockudo connection by providing a url rather than specifying
@@ -136,13 +140,15 @@ module Sockudo
     # Convenience method to set all timeouts to the same value (in seconds).
     # For more control, use the individual writers.
     def timeout=(value)
-      @connect_timeout, @send_timeout, @receive_timeout = value, value, value
+      @connect_timeout = value
+      @send_timeout = value
+      @receive_timeout = value
     end
 
     # Set an encryption_master_key to use with private-encrypted channels from
     # a base64 encoded string.
-    def encryption_master_key_base64=(s)
-      @encryption_master_key = s ? Base64.strict_decode64(s) : nil
+    def encryption_master_key_base64=(str)
+      @encryption_master_key = str ? Base64.strict_decode64(str) : nil
     end
 
     ## INTERACT WITH THE API ##
@@ -169,8 +175,8 @@ module Sockudo
     # @raise [Sockudo::Error] Unsuccessful response - see the error message
     # @raise [Sockudo::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
     #
-    def get(path, params = {})
-      resource(path).get(params)
+    def get(path, params = {}, headers = {})
+      resource(path).get(params, headers)
     end
 
     # GET arbitrary REST API resource using an asynchronous http client.
@@ -185,8 +191,8 @@ module Sockudo
     #
     # @return Either an EM::DefaultDeferrable or a HTTPClient::Connection
     #
-    def get_async(path, params = {})
-      resource(path).get_async(params)
+    def get_async(path, params = {}, headers = {})
+      resource(path).get_async(params, headers)
     end
 
     # POST arbitrary REST API resource using a synchronous http client.
@@ -195,6 +201,12 @@ module Sockudo
       resource(path).post(params, headers)
     end
 
+    # DELETE arbitrary REST API resource using a synchronous http client.
+    # All request signing is handled automatically.
+    def delete(path, params = {}, headers = {})
+      resource(path).delete(params, headers)
+    end
+
     # POST arbitrary REST API resource using an asynchronous http client.
     # Works identially to get_async method, but posts params as JSON in post
     # body.
@@ -227,7 +239,7 @@ module Sockudo
       Channel.new(nil, channel_name, self)
     end
 
-    alias :[] :channel
+    alias [] channel
 
     # Request a list of occupied channels from the API
     #
@@ -260,6 +272,91 @@ module Sockudo
       get("/channels/#{channel_name}", params)
     end
 
+    # Request durable history for a specific channel
+    #
+    # GET /apps/[id]/channels/[channel_name]/history
+    #
+    # @param channel_name [String] Channel name (max 200 characters)
+    # @param params [Hash] Hash of parameters for the API. Supported keys include:
+    #   :limit, :direction, :cursor, :start_serial, :end_serial, :start_time_ms, :end_time_ms
+    #
+    # @return [Hash] See Sockudo history API docs
+    #
+    # @raise [Sockudo::Error] Unsuccessful response - see the error message
+    # @raise [Sockudo::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
+    #
+    def channel_history(channel_name, params = {})
+      get("/channels/#{channel_name}/history", params)
+    end
+
+    # Request presence history for a specific presence channel
+    #
+    # GET /apps/[id]/channels/[channel_name]/presence/history
+    #
+    # @param channel_name [String] Presence channel name (max 200 characters)
+    # @param params [Hash] Hash of parameters for the API. Supported keys include:
+    #   :limit, :direction, :cursor, :start_serial, :end_serial, :start_time_ms, :end_time_ms
+    #
+    # @return [Hash] See Sockudo presence history API docs
+    #
+    def channel_presence_history(channel_name, params = {})
+      get("/channels/#{channel_name}/presence/history", params)
+    end
+
+    # Request a reconstructed presence snapshot for a specific presence channel
+    #
+    # GET /apps/[id]/channels/[channel_name]/presence/history/snapshot
+    #
+    # @param channel_name [String] Presence channel name (max 200 characters)
+    # @param params [Hash] Hash of parameters for the API. Supported keys include:
+    #   :at_time_ms, :at_serial
+    #
+    # @return [Hash] See Sockudo presence snapshot API docs
+    #
+    def channel_presence_snapshot(channel_name, params = {})
+      get("/channels/#{channel_name}/presence/history/snapshot", params)
+    end
+
+    # Request the latest visible version of a mutable message
+    def get_message(channel_name, message_serial, params = {})
+      get("/channels/#{channel_name}/messages/#{message_serial}", params)
+    end
+
+    # Request preserved versions of a mutable message
+    def get_message_versions(channel_name, message_serial, params = {})
+      get("/channels/#{channel_name}/messages/#{message_serial}/versions", params)
+    end
+
+    # Apply a mutable-message update
+    def update_message(channel_name, message_serial, params = {})
+      post("/channels/#{channel_name}/messages/#{message_serial}/update", params)
+    end
+
+    # Apply a mutable-message delete
+    def delete_message(channel_name, message_serial, params = {})
+      post("/channels/#{channel_name}/messages/#{message_serial}/delete", params)
+    end
+
+    # Apply a mutable-message append
+    def append_message(channel_name, message_serial, params = {})
+      post("/channels/#{channel_name}/messages/#{message_serial}/append", params)
+    end
+
+    # Publish an annotation for a versioned message
+    def publish_annotation(channel_name, message_serial, params = {})
+      post("/channels/#{channel_name}/messages/#{message_serial}/annotations", params)
+    end
+
+    # Delete an annotation from a versioned message
+    def delete_annotation(channel_name, message_serial, annotation_serial, params = {})
+      delete("/channels/#{channel_name}/messages/#{message_serial}/annotations/#{annotation_serial}", params)
+    end
+
+    # List raw annotation events for a versioned message
+    def list_annotations(channel_name, message_serial, params = {})
+      get("/channels/#{channel_name}/messages/#{message_serial}/annotations", params)
+    end
+
     # Request info for users of a presence channel
     #
     # GET /apps/[id]/channels/[channel_name]/users
@@ -276,6 +373,114 @@ module Sockudo
       get("/channels/#{channel_name}/users", params)
     end
 
+    # Activate or create a push device registration with admin scope
+    def activate_device(device, options = {})
+      post(push_path('/deviceRegistrations'), device,
+           push_headers('push-admin', nil, rotate_device_identity_token: options[:rotate_device_identity_token]))
+    end
+
+    # Alias of activate_device
+    def create_device_activation(device, options = {})
+      activate_device(device, options)
+    end
+
+    # Update a push device registration with push-subscribe scope
+    def update_device_registration(device, device_identity_token)
+      post(push_path('/deviceRegistrations'), device, push_headers('push-subscribe', device_identity_token))
+    end
+
+    # List push device registrations with cursor pagination
+    def list_device_registrations(params = {})
+      get(push_path('/deviceRegistrations'), params, push_headers('push-admin'))
+    end
+
+    # Get a push device registration
+    def get_device_registration(device_id, device_identity_token = nil)
+      capability = device_identity_token ? 'push-subscribe' : 'push-admin'
+      get(push_path("/deviceRegistrations/#{device_id}"), {}, push_headers(capability, device_identity_token))
+    end
+
+    # Delete a push device registration
+    def delete_device_registration(device_id, device_identity_token = nil)
+      capability = device_identity_token ? 'push-subscribe' : 'push-admin'
+      delete(push_path("/deviceRegistrations/#{device_id}"), {}, push_headers(capability, device_identity_token))
+    end
+
+    # Delete all device registrations for a client identifier
+    def remove_device_registrations_by_client(client_id)
+      delete(push_path('/deviceRegistrations'), { clientId: client_id }, push_headers('push-admin'))
+    end
+
+    # Upsert a push channel subscription
+    def upsert_channel_push_subscription(subscription, device_identity_token = nil)
+      capability = device_identity_token ? 'push-subscribe' : 'push-admin'
+      post(push_path('/channelSubscriptions'), subscription, push_headers(capability, device_identity_token))
+    end
+
+    # List push channel subscriptions with cursor pagination
+    def list_channel_push_subscriptions(params = {}, device_identity_token = nil)
+      capability = device_identity_token ? 'push-subscribe' : 'push-admin'
+      get(push_path('/channelSubscriptions'), params, push_headers(capability, device_identity_token))
+    end
+
+    # Delete push channel subscriptions
+    def delete_channel_push_subscriptions(params = {}, device_identity_token = nil)
+      capability = device_identity_token ? 'push-subscribe' : 'push-admin'
+      delete(push_path('/channelSubscriptions'), params, push_headers(capability, device_identity_token))
+    end
+
+    # List subscribed channels with cursor pagination
+    def list_channel_push_subscription_channels(params = {})
+      get(push_path('/channelSubscriptions/channels'), params, push_headers('push-admin'))
+    end
+
+    # List stored push provider credentials with cursor pagination
+    def list_push_credentials(params = {})
+      get(push_path('/credentials'), params, push_headers('push-admin'))
+    end
+
+    # Store or update a provider credential payload
+    def put_push_credential(provider, credential)
+      post(push_path("/credentials/#{provider}"), credential, push_headers('push-admin'))
+    end
+
+    # Publish push asynchronously by default
+    def publish_push(request)
+      post(push_path('/publish'), request.merge(sync: false), push_headers('push-admin'))
+    end
+
+    # Alias of publish_push
+    def publish_push_direct(request)
+      publish_push(request)
+    end
+
+    # Publish a batch of push notifications asynchronously by default
+    def publish_push_batch(requests)
+      post(push_path('/batch/publish'), requests.map { |request| request.merge(sync: false) }, push_headers('push-admin'))
+    end
+
+    # Schedule a push publish; requires notBeforeMs in the request
+    def schedule_push(request)
+      raise Sockudo::Error, 'scheduled push requires notBeforeMs' unless request.key?(:notBeforeMs) || request.key?('notBeforeMs')
+
+      publish_push(request)
+    end
+
+    # Get the status for a publish id
+    def get_publish_status(publish_id)
+      get(push_path("/publish/#{publish_id}/status"), {}, push_headers('push-admin'))
+    end
+
+    # Cancel a scheduled publish
+    def cancel_scheduled_push(publish_id)
+      delete(push_path("/scheduled/#{publish_id}"), {}, push_headers('push-admin'))
+    end
+
+    # Submit a provider delivery status event
+    def post_push_delivery_status(event)
+      post(push_path('/deliveryStatus'), event, push_headers('push-admin'))
+    end
+
     # Trigger an event on one or more channels
     #
     # POST /apps/[app_id]/events
@@ -334,7 +539,6 @@ module Sockudo
       post_async('/batch_events', trigger_batch_params(flat_events))
     end
 
-
     # Generate the expected response for an authentication endpoint.
     # See https://sockudo.com/docs/channels/server_api/authorizing-users for details.
     #
@@ -399,42 +603,37 @@ module Sockudo
     def sync_http_client
       require 'httpclient'
 
-      @client ||= begin
-        HTTPClient.new(@http_proxy).tap do |c|
-          c.connect_timeout = @connect_timeout
-          c.send_timeout = @send_timeout
-          c.receive_timeout = @receive_timeout
-          c.keep_alive_timeout = @keep_alive_timeout
-        end
+      @sync_http_client ||= HTTPClient.new(@http_proxy).tap do |c|
+        c.connect_timeout = @connect_timeout
+        c.send_timeout = @send_timeout
+        c.receive_timeout = @receive_timeout
+        c.keep_alive_timeout = @keep_alive_timeout
       end
     end
 
     # @private Construct an em-http-request http client
     def em_http_client(uri)
-      begin
-        unless defined?(EventMachine) && EventMachine.reactor_running?
-          raise Error, "In order to use async calling you must be running inside an eventmachine loop"
-        end
-        require 'em-http' unless defined?(EventMachine::HttpRequest)
+      unless defined?(EventMachine) && EventMachine.reactor_running?
+        raise Error, 'In order to use async calling you must be running inside an eventmachine loop'
+      end
 
-        connection_opts = {
-          connect_timeout: @connect_timeout,
-          inactivity_timeout: @receive_timeout,
-        }
+      require 'em-http' unless defined?(EventMachine::HttpRequest)
 
-        if defined?(@proxy)
-          proxy_opts = {
-            host: @proxy[:host],
-            port: @proxy[:port]
-          }
-          if @proxy[:user]
-            proxy_opts[:authorization] = [@proxy[:user], @proxy[:password]]
-          end
-          connection_opts[:proxy] = proxy_opts
-        end
+      connection_opts = {
+        connect_timeout: @connect_timeout,
+        inactivity_timeout: @receive_timeout
+      }
 
-        EventMachine::HttpRequest.new(uri, connection_opts)
+      if defined?(@proxy)
+        proxy_opts = {
+          host: @proxy[:host],
+          port: @proxy[:port]
+        }
+        proxy_opts[:authorization] = [@proxy[:user], @proxy[:password]] if @proxy[:user]
+        connection_opts[:proxy] = proxy_opts
       end
+
+      EventMachine::HttpRequest.new(uri, connection_opts)
     end
 
     private
@@ -443,16 +642,19 @@ module Sockudo
 
     def inject_auto_idempotency_key(params)
       return params if params.key?(:idempotency_key) || !@auto_idempotency_key
+
       serial = (@publish_serial += 1)
       params.merge(idempotency_key: "#{@base_id}:#{serial}")
     end
 
     def inject_auto_idempotency_keys_batch!(events)
       return false unless @auto_idempotency_key
+
       serial = (@publish_serial += 1)
       injected = false
       events.each_with_index do |event, index|
         next if event.key?(:idempotency_key)
+
         event[:idempotency_key] = "#{@base_id}:#{serial}:#{index}"
         injected = true
       end
@@ -462,19 +664,15 @@ module Sockudo
     def post_with_retry(path, body, headers = {})
       last_error = nil
       @max_retries.times do |attempt|
-        begin
-          return post(path, body, headers)
-        rescue Sockudo::HTTPError => e
-          last_error = e
-          raise unless attempt < @max_retries - 1
-        rescue Sockudo::Error => e
-          if e.respond_to?(:status) && e.status.is_a?(Integer) && e.status >= 500 && e.status < 600
-            last_error = e
-            raise unless attempt < @max_retries - 1
-          else
-            raise
-          end
-        end
+        return post(path, body, headers)
+      rescue Sockudo::HTTPError => e
+        last_error = e
+        raise unless attempt < @max_retries - 1
+      rescue Sockudo::Error => e
+        raise unless e.respond_to?(:status) && e.status.is_a?(Integer) && e.status >= 500 && e.status < 600
+
+        last_error = e
+        raise unless attempt < @max_retries - 1
       end
       raise last_error
     end
@@ -483,18 +681,22 @@ module Sockudo
       channels = Array(channels).map(&:to_s)
       raise Sockudo::Error, "Too many channels (#{channels.length}), max 100" if channels.length > 100
 
-      encoded_data = if channels.any?{ |c| c.match(/^private-encrypted-/) } then
-        raise Sockudo::Error, "Cannot trigger to multiple channels if any are encrypted" if channels.length > 1
-        encrypt(channels[0], encode_data(data))
-      else
-        encode_data(data)
-      end
+      encoded_data = if channels.any? { |c| c.match(/^private-encrypted-/) }
+                       if channels.length > 1
+                         raise Sockudo::Error,
+                               'Cannot trigger to multiple channels if any are encrypted'
+                       end
+
+                       encrypt(channels[0], encode_data(data))
+                     else
+                       encode_data(data)
+                     end
 
       params.merge({
-        name: event_name,
-        channels: channels,
-        data: encoded_data,
-      })
+                     name: event_name,
+                     channels: channels,
+                     data: encoded_data
+                   })
     end
 
     def trigger_params_with_headers(channels, event_name, data, params)
@@ -513,11 +715,11 @@ module Sockudo
       {
         batch: events.map do |event|
           event.dup.tap do |e|
-            e[:data] = if e[:channel].match(/^private-encrypted-/) then
-              encrypt(e[:channel], encode_data(e[:data]))
-            else
-              encode_data(e[:data])
-            end
+            e[:data] = if e[:channel].match(/^private-encrypted-/)
+                         encrypt(e[:channel], encode_data(e[:data]))
+                       else
+                         encode_data(e[:data])
+                       end
           end
         end
       }
@@ -526,6 +728,7 @@ module Sockudo
     # JSON-encode the data if it's not a string
     def encode_data(data)
       return data if data.is_a? String
+
       MultiJson.encode(data)
     end
 
@@ -546,9 +749,9 @@ module Sockudo
       ciphertext = secret_box.encrypt(nonce, encoded_data)
 
       MultiJson.encode({
-        "nonce" => Base64::strict_encode64(nonce),
-        "ciphertext" => Base64::strict_encode64(ciphertext),
-      })
+                         'nonce' => Base64.strict_encode64(nonce),
+                         'ciphertext' => Base64.strict_encode64(ciphertext)
+                       })
     end
 
     def configured?
@@ -558,7 +761,7 @@ module Sockudo
     def require_rbnacl
       require 'rbnacl'
     rescue LoadError => e
-      $stderr.puts "You don't have rbnacl installed in your application. Please add it to your Gemfile and run bundle install"
+      warn "You don't have rbnacl installed in your application. Please add it to your Gemfile and run bundle install"
       raise e
     end
 
@@ -575,7 +778,7 @@ module Sockudo
     # @raise [Sockudo::Error] if socket_id or custom_string invalid
     #
     def authentication_string(socket_id, custom_string = nil)
-      string_to_sign = [socket_id, 'user', custom_string].compact.map(&:to_s).join('::')
+      string_to_sign = [socket_id, 'user', custom_string].compact.join('::')
 
       _authentication_string(socket_id, string_to_sign, authentication_token, string_to_sign)
     end
@@ -589,5 +792,16 @@ module Sockudo
     def user_data_valid?(data)
       data.is_a?(Hash) && data.key?(:id) && !data[:id].empty? && data[:id].is_a?(String)
     end
+
+    def push_headers(capability = 'push-admin', device_identity_token = nil, rotate_device_identity_token: false)
+      headers = { 'X-Sockudo-Push-Capability' => capability }
+      headers['X-Sockudo-Device-Identity-Token'] = device_identity_token if device_identity_token
+      headers['X-Sockudo-Rotate-Device-Identity-Token'] = 'true' if rotate_device_identity_token
+      headers
+    end
+
+    def push_path(path)
+      "/push#{path}"
+    end
   end
 end