matrix_sdk 2.3.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb2cd8492e977a8c63d80d3a250841111f872b45ef48a06ac610dd6c871c5704
-  data.tar.gz: b5932dc63938f86a4bec522f2d5736871f3a5461ad5d25581c2ba1cd79b20ab2
+  metadata.gz: 50821866efab2cbd39daf23bc9ff3bd7864bca5638f76c766a8ba26ab91c7423
+  data.tar.gz: 2601cf5141e824b322f5310e09b72d42059162e1ac87da11243167d2604f1801
 SHA512:
-  metadata.gz: 0ed57a7d4b3296a15c244c88ca88777d6ed3f9b67a6c4cdaae017f56c6e15cf94ba0781c6831a70f7adf9c55605073c84c451b0c1b0b8bffe323015330294f19
-  data.tar.gz: f77aaa05a45917b80aa296b7ff73f37d60ba5fb36f29a3e753cec1a730681a428c33ccdae9f4c26648952d6a7b05f9636e7d7ffbbe8757d23d2c435378d3466b
+  metadata.gz: 7bb45dfcb6696b75ed0be95b92fbb3f569b258d4d0456a3cd8ea16fd22d5e3d5050607e6229bfa0e32b84fc0248e554db8f93d48cd970b2ff95475cf0bcfba85
+  data.tar.gz: 58d8524e9d83ef570ca19a41f28758fc129c1a3988ea3522a994e58eaa93c4807850b63a2171423dd69a948738e69468542d56d882ecf98c60e6f8607928b6d1

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 2.6.0 - 2022-07-15
+
+- Adds some multi-thread usage support to the API (create your API/client with `threadsafe: :multithread/true/false`)
+    The API will currently default to running with multi-threaded requests. In case your application is single-threaded - or never performs requests from multiple threads - then you can set `threadsafe: true/false` to support connection reuse.
+- Changes room finding to ignore non-canonical aliases by default
+- Improves room alias handling
+- Improves Ruby 3.0+ support
+- Improves debug output by supporting PP (Ruby pretty print) on all MatrixSdk objects
+
+## 2.5.0 - 2022-01-14
+
+- Adds preliminary support for the Matrix v1.1 `client/v3` API
+- Adds some support for knocking rooms
+- Adds mutex synchronization on API requests to avoid some threading issues
+- Fixes error on attempting to skip cache for certain requests (#19)
+- Fixes inconsistency in MXID typing for the Client abstraction (#18 #20)
+- Fixes missed autoloader entries for errors (#22)
+- Fixes some potential issues arising from broken user-provided state data
+
+## 2.4.0 - 2021-07-19
+
+- Adds support for matrix: URI's according to MSC2312
+- Adds some basic support for detecting Spaces (MSC1772)
+- Fixes sync against Synapse 1.38.0 missing empty fields
+
 ## 2.3.0 - 2021-03-26
 
 - Adds support for Ruby 3.0 (#15)

data/README.md

@@ -8,6 +8,8 @@ Live YARD documentation can be found at; https://ruby-sdk.ananace.dev
 
 ## Example usage
 
+For more fully-featured examples, check the [examples](examples/) folder.
+
 ```ruby
 # Raw API usage
 require 'matrix_sdk'

data/lib/matrix_sdk/api.rb

@@ -19,7 +19,7 @@ module MatrixSdk
     }.freeze
 
     attr_accessor :access_token, :connection_address, :connection_port, :device_id, :autoretry, :global_headers
-    attr_reader :homeserver, :validate_certificate, :open_timeout, :read_timeout, :well_known, :proxy_uri
+    attr_reader :homeserver, :validate_certificate, :open_timeout, :read_timeout, :well_known, :proxy_uri, :threadsafe
 
     ignore_inspect :access_token, :logger
 
@@ -39,7 +39,10 @@ module MatrixSdk
     # @option params [Hash] :global_headers Additional headers to set for all requests
     # @option params [Boolean] :skip_login Should the API skip logging in if the HS URL contains user information
     # @option params [Boolean] :synapse (true) Is the API connecting to a Synapse instance
-    # @option params [Hash] :well_known The .well-known object that the server was discovered through, should not be set manually
+    # @option params [Boolean,:multithread] :threadsafe (:multithread) Should the connection be threadsafe/mutexed - or
+    #   safe for simultaneous multi-thread usage. Will default to +:multithread+ - a.k.a. per-thread HTTP connections
+    #   and requests
+    # @note Using threadsafe +:multithread+ currently doesn't support connection re-use
     def initialize(homeserver, **params)
       @homeserver = homeserver
       raise ArgumentError, 'Homeserver URL must be String or URI' unless @homeserver.is_a?(String) || @homeserver.is_a?(URI)
@@ -57,14 +60,16 @@ module MatrixSdk
       @validate_certificate = params.fetch(:validate_certificate, false)
       @transaction_id = params.fetch(:transaction_id, 0)
       @backoff_time = params.fetch(:backoff_time, 5000)
-      @open_timeout = params.fetch(:open_timeout, 60)
-      @read_timeout = params.fetch(:read_timeout, 240)
+      @open_timeout = params.fetch(:open_timeout, nil)
+      @read_timeout = params.fetch(:read_timeout, nil)
       @well_known = params.fetch(:well_known, {})
       @global_headers = DEFAULT_HEADERS.dup
       @global_headers.merge!(params.fetch(:global_headers)) if params.key? :global_headers
       @synapse = params.fetch(:synapse, true)
       @http = nil
 
+      self.threadsafe = params.fetch(:threadsafe, :multithread)
+
       ([params.fetch(:protocols, [:CS])].flatten - protocols).each do |proto|
         self.class.include MatrixSdk::Protocols.const_get(proto)
       end
@@ -243,6 +248,17 @@ module MatrixSdk
       @proxy_uri = proxy_uri
     end
 
+    # @param [Boolean,:multithread] threadsafe What level of thread-safety the API should use
+    # @return [Boolean,:multithread]
+    def threadsafe=(threadsafe)
+      raise ArgumentError, 'Threadsafe must be either a boolean or :multithread' unless [true, false, :multithread].include? threadsafe
+      raise ArugmentError, 'JRuby only support :multithread/false for threadsafe' if RUBY_ENGINE == 'jruby' && threadsafe == true
+
+      @threadsafe = threadsafe
+      @http_lock = nil unless threadsafe == true
+      @threadsafe
+    end
+
     # Perform a raw Matrix API request
     #
     # @example Simple API query
@@ -281,15 +297,25 @@ module MatrixSdk
 
         req_obj = construct_request(url: url, method: method, **options)
         print_http(req_obj, id: req_id)
-        begin
+        response = duration = nil
+
+        loc_http = http
+        perform_request = proc do
           dur_start = Time.now
-          response = http.request req_obj
+          response = loc_http.request req_obj
           dur_end = Time.now
           duration = dur_end - dur_start
         rescue EOFError
           logger.error 'Socket closed unexpectedly'
           raise
         end
+
+        if @threadsafe == true
+          http_lock.synchronize { perform_request.call }
+        else
+          perform_request.call
+          loc_http.finish if @threadsafe == :multithread
+        end
         print_http(response, duration: duration, id: req_id)
 
         begin
@@ -392,18 +418,26 @@ module MatrixSdk
 
       host = (@connection_address || homeserver.host)
       port = (@connection_port || homeserver.port)
-      @http ||= if proxy_uri
-                  Net::HTTP.new(host, port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
-                else
-                  Net::HTTP.new(host, port)
-                end
-
-      @http.open_timeout = open_timeout
-      @http.read_timeout = read_timeout
-      @http.use_ssl = homeserver.scheme == 'https'
-      @http.verify_mode = validate_certificate ? ::OpenSSL::SSL::VERIFY_PEER : ::OpenSSL::SSL::VERIFY_NONE
-      @http.start
-      @http
+
+      connection = @http unless @threadsafe == :multithread
+      connection ||= if proxy_uri
+                       Net::HTTP.new(host, port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+                     else
+                       Net::HTTP.new(host, port)
+                     end
+
+      connection.open_timeout = open_timeout if open_timeout
+      connection.read_timeout = read_timeout if read_timeout
+      connection.use_ssl = homeserver.scheme == 'https'
+      connection.verify_mode = validate_certificate ? ::OpenSSL::SSL::VERIFY_PEER : ::OpenSSL::SSL::VERIFY_NONE
+      connection.start
+      @http = connection unless @threadsafe == :multithread
+
+      connection
+    end
+
+    def http_lock
+      @http_lock ||= Mutex.new if @threadsafe == true
     end
   end
 end

data/lib/matrix_sdk/client.rb

@@ -73,6 +73,7 @@ module MatrixSdk
 
       @cache = client_cache
       @identity_server = nil
+      @mxid = nil
 
       @sync_token = nil
       @sync_thread = nil
@@ -102,9 +103,8 @@ module MatrixSdk
     #
     # @return [MXID] The MXID of the current user
     def mxid
-      @mxid ||= begin
-        MXID.new api.whoami?[:user_id] if api&.access_token
-      end
+      @mxid ||= MXID.new api.whoami?[:user_id] if api&.access_token
+      @mxid
     end
 
     alias user_id mxid
@@ -161,9 +161,7 @@ module MatrixSdk
     #
     # @return [Hash[String,Array[String]]] A mapping of MXIDs to a list of direct rooms with that user
     def direct_rooms
-      Hash[api.get_account_data(mxid, 'm.direct').map do |mxid, rooms|
-        [mxid.to_s, rooms]
-      end]
+      api.get_account_data(mxid, 'm.direct').transform_keys(&:to_s)
     end
 
     # Gets a direct message room for the given user if one exists
@@ -194,6 +192,19 @@ module MatrixSdk
       @rooms.values
     end
 
+    # Get a list of all joined Matrix Spaces
+    #
+    # @return [Array[Room]] All the currently joined Spaces
+    def spaces
+      rooms = if cache == :none
+                api.get_joined_rooms.joined_rooms.map { |id| Room.new(self, id) }
+              else
+                self.rooms
+              end
+
+      rooms.select(&:space?)
+    end
+
     # Refresh the list of currently handled rooms, replacing it with the user's
     # currently joined rooms.
     #
@@ -211,6 +222,7 @@ module MatrixSdk
       true
     end
     alias refresh_rooms! reload_rooms!
+    alias reload_spaces! reload_rooms!
 
     # Register - and log in - on the connected HS as a guest
     #
@@ -383,15 +395,16 @@ module MatrixSdk
     # @param only_canonical [Boolean] Only match alias against the canonical alias
     # @return [Room] The found room
     # @return [nil] If no room was found
-    def find_room(room_id_or_alias, only_canonical: false)
+    def find_room(room_id_or_alias, only_canonical: true)
       room_id_or_alias = MXID.new(room_id_or_alias.to_s) unless room_id_or_alias.is_a? MXID
       raise ArgumentError, 'Must be a room id or alias' unless room_id_or_alias.room?
 
       return @rooms.fetch(room_id_or_alias.to_s, nil) if room_id_or_alias.room_id?
 
-      return @rooms.values.find { |r| r.canonical_alias == room_id_or_alias.to_s } if only_canonical
+      room = @rooms.values.find { |r| r.aliases.include? room_id_or_alias.to_s }
+      return room if only_canonical
 
-      @rooms.values.find { |r| r.aliases.include? room_id_or_alias.to_s }
+      room || @rooms.values.find { |r| r.aliases(canonical_only: false).include? room_id_or_alias.to_s }
     end
 
     # Get a User instance from a MXID
@@ -429,13 +442,13 @@ module MatrixSdk
 
     # Upload a piece of data to the media repo
     #
-    # @return [URI::MATRIX] A Matrix content (mxc://) URL pointing to the uploaded data
+    # @return [URI::MXC] A Matrix content (mxc://) URL pointing to the uploaded data
     # @param content [String] The data to upload
     # @param content_type [String] The MIME type of the data
     # @see Protocols::CS#media_upload
     def upload(content, content_type)
       data = api.media_upload(content, content_type)
-      return data[:content_uri] if data.key? :content_uri
+      return URI(data[:content_uri]) if data.key? :content_uri
 
       raise MatrixUnexpectedResponseError, 'Upload succeeded, but no media URI returned'
     end
@@ -518,11 +531,9 @@ module MatrixSdk
 
       attempts = 0
       data = loop do
-        begin
-          break api.sync **extra_params
-        rescue MatrixSdk::MatrixTimeoutError => e
-          raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
-        end
+        break api.sync(**extra_params)
+      rescue MatrixSdk::MatrixTimeoutError => e
+        raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
       end
 
       @next_batch = data[:next_batch] unless skip_store_batch
@@ -542,11 +553,14 @@ module MatrixSdk
       raise ArgumentError, 'Must be a room ID' unless room_id.room_id?
 
       room_id = room_id.to_s
-      @rooms.fetch(room_id) do
+      ret = @rooms.fetch(room_id) do
         room = Room.new(self, room_id)
         @rooms[room_id] = room unless cache == :none
         room
       end
+      # Need to figure out a way to handle multiple types
+      ret = @rooms[room_id] = ret.to_space if ret.instance_variable_get :@room_type
+      ret
     end
 
     def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 0, **params)
@@ -575,7 +589,7 @@ module MatrixSdk
     private
 
     def post_authentication(data)
-      @mxid = data[:user_id]
+      @mxid = MXID.new data[:user_id]
       @api.access_token = data[:access_token]
       @api.device_id = data[:device_id]
       @api.homeserver = data[:home_server]
@@ -592,35 +606,35 @@ module MatrixSdk
     end
 
     def handle_sync_response(data)
-      data[:presence][:events].each do |presence_update|
+      data.dig(:presence, :events)&.each do |presence_update|
         fire_presence_event(MatrixEvent.new(self, presence_update))
       end
 
-      data[:rooms][:invite].each do |room_id, invite|
+      data.dig(:rooms, :invite)&.each do |room_id, invite|
         invite[:room_id] = room_id.to_s
         fire_invite_event(MatrixEvent.new(self, invite), room_id.to_s)
       end
 
-      data[:rooms][:leave].each do |room_id, left|
+      data.dig(:rooms, :leave)&.each do |room_id, left|
         left[:room_id] = room_id.to_s
         fire_leave_event(MatrixEvent.new(self, left), room_id.to_s)
       end
 
-      data[:rooms][:join].each do |room_id, join|
+      data.dig(:rooms, :join)&.each do |room_id, join|
         room = ensure_room(room_id)
-        room.instance_variable_set '@prev_batch', join[:timeline][:prev_batch]
+        room.instance_variable_set '@prev_batch', join.dig(:timeline, :prev_batch)
         room.instance_variable_set :@members_loaded, true unless sync_filter.fetch(:room, {}).fetch(:state, {}).fetch(:lazy_load_members, false)
 
-        join[:state][:events].each do |event|
+        join.dig(:state, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           handle_state(room_id, event)
         end
 
-        join[:timeline][:events].each do |event|
+        join.dig(:timeline, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           # Avoid sending two identical state events if it's both in state and timeline
           if event.key?(:state_key)
-            state_event = join.dig(:state, :events).find { |ev| ev[:event_id] == event[:event_id] }
+            state_event = join.dig(:state, :events)&.find { |ev| ev[:event_id] == event[:event_id] }
 
             handle_state(room_id, event) unless event == state_event
           end
@@ -629,7 +643,7 @@ module MatrixSdk
           fire_event(MatrixEvent.new(self, event), event[:type])
         end
 
-        join[:ephemeral][:events].each do |event|
+        join.dig(:ephemeral, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           room.send :put_ephemeral_event, event
 

data/lib/matrix_sdk/mxid.rb

@@ -12,7 +12,7 @@ module MatrixSdk
 
       # TODO: Community-as-a-Room / Profile-as-a-Room, in case they're going for room aliases
       @sigil = identifier[0]
-      @localpart, @domain, @port = identifier[1..-1].split(':')
+      @localpart, @domain, @port = identifier[1..-1].split(':') # rubocop:disable Style/SlicingWithRange # Keep support for slightly older Rubies
       @port = @port.to_i if @port
 
       raise ArgumentError, 'Identifier is not a valid MXID' unless valid?
@@ -100,5 +100,45 @@ module MatrixSdk
     def room_alias?
       type == :room_alias
     end
+
+    # Converts the MXID to a matrix: URI according to MSC2312
+    # @param event_id [String,MXID] An event ID to append to the URI (only valid for rooms)
+    # @param action [String,Symbol] The action that should be requested
+    # @param via [Array[String]] The list of servers to use for a join
+    # @see https://github.com/matrix-org/matrix-doc/blob/master/proposals/2312-matrix-uri.md
+    def to_uri(event_id: nil, action: nil, via: nil)
+      uri = ''
+
+      case sigil
+      when '@'
+        raise ArgumentError, "can't provide via for user URIs" if via
+        raise ArgumentError, "can't provide event_id for user URIs" if event_id
+
+        uri += 'u'
+      when '#'
+        uri += 'r'
+      when '!'
+        uri += 'roomid'
+      else
+        raise ArgumentError, "this MXID can't be converted to a URI"
+      end
+
+      uri = "matrix:#{uri}/#{localpart}#{homeserver_suffix}"
+
+      uri += "/e/#{event_id.to_s.delete_prefix('$')}" if event_id
+      query = []
+      query << "action=#{action}" if action
+      [via].flatten.compact.each { |v| query << "via=#{v}" }
+
+      uri += "?#{query.join('&')}" unless query.empty?
+
+      URI(uri)
+    end
+
+    # Check if two MXIDs are equal
+    # @return [Boolean]
+    def ==(other)
+      to_s == other.to_s
+    end
   end
 end