matrix_sdk 2.0.0 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e0e5819346e56fd4eac1564434e88399500adefe0def16bc706a25ec7a254b2
-  data.tar.gz: 2d74cd2d5203f5431396b03717c4302f9a0c7816c47eaa969e2395ab2eb46586
+  metadata.gz: 550080056a38ee354ff8e633069d71f207e1927a567fcaed4f7ed9792bcbb79a
+  data.tar.gz: ae8909f5a1092873453c4b7a876315efd29882cee353252d9bd92f069ce3c4ac
 SHA512:
-  metadata.gz: 7eb8ef8277b0bda1191915e5be4dcf93856cd876f611b77974b8dc88e5e230ba5c3300995157f9717a4b00d1a7cba7f7a618844cc436ad0b6a3ea5865367049d
-  data.tar.gz: bd888c36cf3a082360dbecc408c0a67e16ddb337a721105be7abf3a9662d81bfa564a1093a64d1f934d484af6a22a36e5b91bafde70f02a882e6d092e81d5459
+  metadata.gz: 5838b47c8ea7df7becdb7dadcb07e57c31526c8c3cdd025a18cc2add7db9e9da9f0aff62a16ed4a3a5306566785f941e7cdba90e664f2b872959c7774b4ec4bc
+  data.tar.gz: 3fcad5ea834b2dd0e6d68e55a8e88e5a88b444d07491f381420c4749ca1ff5375030f3a7c4b1b535ff947422caf7c4b86f81633d425614a05e5577aa9a4963ff

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## 2.1.3 - 2020-09-18
+
+- Adds separate state event handler as Client#on_state_event
+- Changes Client sync interval to by-default run at full speed
+- Fixes state events being sent twice if included in both timeline and state of a sync
+- Improves error reporting of broken 200 responses
+- Improves event handlers for rooms, to not depend on a specific room object instance anymore
+
+## 2.1.2 - 2020-09-10
+
+- Adds method for reading complete member lists for rooms, improves the CS spec adherence
+- Adds test for state events
+- Fixes state event handler for rooms not actually passing events
+- Fixes Api#new_for_domain using a faulty URI in certain cases
+
+## 2.1.1 - 2020-08-21
+
+- Fixes crash if state event content is null (#11)
+- Fixes an uninitialized URI constant exception when requiring only the main library file
+- Fixes the Api#get_pushrules method missing an ending slash in the request URI
+- Fixes discovery code for client/server connections based on domain
+
+## 2.1.0 - 2020-05-22
+
+- Adds unique query IDs as well as duration in API debug output, to make it easier to track long requests
+- Finishes up MSC support, get sync over SSE working flawlessly
+- Exposes the #listen_forever method in the client abstraction
+- Fixes room access methods
+
+## 2.0.1 - 2020-03-13
+
+- Adds code for handling non-final MSC's in protocols
+  - Currently implementing clients parts of MSC2018 for Sync over Server Sent Events
+
 ## 2.0.0 - 2020-02-14
 
 **NB**, this release includes backwards-incompatible changes;  

data/lib/matrix_sdk.rb

@@ -27,6 +27,9 @@ module MatrixSdk
     autoload :CS, 'matrix_sdk/protocols/cs'
     autoload :IS, 'matrix_sdk/protocols/is'
     autoload :SS, 'matrix_sdk/protocols/ss'
+
+    # Non-final protocol extensions
+    autoload :MSC, 'matrix_sdk/protocols/msc'
   end
 
   def self.debug!

data/lib/matrix_sdk/api.rb

@@ -11,10 +11,6 @@ module MatrixSdk
   class Api
     extend MatrixSdk::Extensions
     include MatrixSdk::Logging
-    include MatrixSdk::Protocols::AS
-    include MatrixSdk::Protocols::CS
-    include MatrixSdk::Protocols::IS
-    include MatrixSdk::Protocols::SS
 
     USER_AGENT = "Ruby Matrix SDK v#{MatrixSdk::VERSION}"
     DEFAULT_HEADERS = {
@@ -23,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, :protocols, :well_known, :proxy_uri
+    attr_reader :homeserver, :validate_certificate, :open_timeout, :read_timeout, :well_known, :proxy_uri
 
     ignore_inspect :access_token, :logger
 
@@ -51,10 +47,6 @@ module MatrixSdk
       @homeserver.path.gsub!(/\/?_matrix\/?/, '') if @homeserver.path =~ /_matrix\/?$/
       raise ArgumentError, 'Please use the base URL for your HS (without /_matrix/)' if @homeserver.path.include? '/_matrix/'
 
-      @protocols = params.fetch(:protocols, %i[CS])
-      @protocols = [@protocols] unless @protocols.is_a? Array
-      @protocols << :CS if @protocols.include?(:AS) && !@protocols.include?(:CS)
-
       @proxy_uri = params.fetch(:proxy_uri, nil)
       @connection_address = params.fetch(:address, nil)
       @connection_port = params.fetch(:port, nil)
@@ -71,6 +63,10 @@ module MatrixSdk
       @global_headers.merge!(params.fetch(:global_headers)) if params.key? :global_headers
       @http = nil
 
+      ([params.fetch(:protocols, [:CS])].flatten - protocols).each do |proto|
+        self.class.include MatrixSdk::Protocols.const_get(proto)
+      end
+
       login(user: @homeserver.user, password: @homeserver.password) if @homeserver.user && @homeserver.password && !@access_token && !params[:skip_login] && protocol?(:CS)
       @homeserver.userinfo = '' unless params[:skip_login]
     end
@@ -96,6 +92,8 @@ module MatrixSdk
       uri = URI("http#{ssl ? 's' : ''}://#{domain}")
       well_known = nil
       target_uri = nil
+      logger = ::Logging.logger[self]
+      logger.debug "Resolving #{domain}"
 
       if !port.nil? && !port.empty?
         # If the domain is fully qualified according to Matrix (FQDN and port) then skip discovery
@@ -103,21 +101,30 @@ module MatrixSdk
       elsif target == :server
         # Attempt SRV record discovery
         target_uri = begin
-                       require 'resolv'
-                       resolver = Resolv::DNS.new
-                       resolver.getresource("_matrix._tcp.#{domain}")
-                     rescue StandardError
-                       nil
-                     end
+          require 'resolv'
+          resolver = Resolv::DNS.new
+          srv = "_matrix._tcp.#{domain}"
+          logger.debug "Trying DNS #{srv}..."
+          d = resolver.getresource(srv, Resolv::DNS::Resource::IN::SRV)
+          d
+        rescue StandardError => e
+          logger.debug "DNS lookup failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if target_uri.nil?
           # Attempt .well-known discovery for server-to-server
           well_known = begin
-                         data = Net::HTTP.get("https://#{domain}/.well-known/matrix/server")
-                         JSON.parse(data)
-                       rescue StandardError
-                         nil
-                       end
+            wk_uri = URI("https://#{domain}/.well-known/matrix/server")
+            logger.debug "Trying #{wk_uri}..."
+            data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+              http.get(wk_uri.path).body
+            end
+            JSON.parse(data)
+          rescue StandardError => e
+            logger.debug "Well-known failed with #{e.class}: #{e.message}"
+            nil
+          end
 
           target_uri = well_known['m.server'] if well_known&.key?('m.server')
         else
@@ -126,11 +133,16 @@ module MatrixSdk
       elsif %i[client identity].include? target
         # Attempt .well-known discovery
         well_known = begin
-                       data = Net::HTTP.get("https://#{domain}/.well-known/matrix/client")
-                       JSON.parse(data)
-                     rescue StandardError
-                       nil
-                     end
+          wk_uri = URI("https://#{domain}/.well-known/matrix/client")
+          logger.debug "Trying #{wk_uri}..."
+          data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+            http.get(wk_uri.path).body
+          end
+          JSON.parse(data)
+        rescue StandardError => e
+          logger.debug "Well-known failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if well_known
           key = 'm.homeserver'
@@ -142,6 +154,7 @@ module MatrixSdk
           end
         end
       end
+      logger.debug "Using #{target_uri.inspect}"
 
       # Fall back to direct domain connection
       target_uri ||= URI("https://#{domain}:8448")
@@ -155,6 +168,21 @@ module MatrixSdk
           ))
     end
 
+    # Get a list of enabled protocols on the API client
+    #
+    # @example
+    #   MatrixSdk::Api.new_for_domain('matrix.org').protocols
+    #   # => [:IS, :CS]
+    #
+    # @return [Symbol[]] An array of enabled APIs
+    def protocols
+      self
+        .class.included_modules
+        .reject { |m| m&.name.nil? }
+        .select { |m| m.name.start_with? 'MatrixSdk::Protocols::' }
+        .map { |m| m.name.split('::').last.to_sym }
+    end
+
     # Check if a protocol is enabled on the API connection
     #
     # @example Checking for identity server API support
@@ -233,6 +261,7 @@ module MatrixSdk
     # @option options [Hash,String] :body The body to attach to the request, will be JSON-encoded if sent as a hash
     # @option options [IO] :body_stream A body stream to attach to the request
     # @option options [Hash] :headers Additional headers to set on the request
+    # @option options [Boolean] :skip_auth (false) Skip authentication
     def request(method, api, path, **options)
       url = homeserver.dup.tap do |u|
         u.path = api_to_path(api) + path
@@ -250,7 +279,7 @@ module MatrixSdk
         request.content_length = (request.body || request.body_stream).size
       end
 
-      request['authorization'] = "Bearer #{access_token}" if access_token
+      request['authorization'] = "Bearer #{access_token}" if access_token && !options.fetch(:skip_auth, false)
       if options.key? :headers
         options[:headers].each do |h, v|
           request[h.to_s.downcase] = v
@@ -261,15 +290,26 @@ module MatrixSdk
       loop do
         raise MatrixConnectionError, "Server still too busy to handle request after #{failures} attempts, try again later" if failures >= 10
 
-        print_http(request)
+        req_id = ('A'..'Z').to_a.sample(4).join
+
+        print_http(request, id: req_id)
         begin
+          dur_start = Time.now
           response = http.request request
-        rescue EOFError => e
+          dur_end = Time.now
+          duration = dur_end - dur_start
+        rescue EOFError
           logger.error 'Socket closed unexpectedly'
-          raise e
+          raise
+        end
+        print_http(response, duration: duration, id: req_id)
+
+        begin
+          data = JSON.parse(response.body, symbolize_names: true)
+        rescue JSON::JSONError => e
+          logger.debug "#{e.class} error when parsing response. #{e}"
+          data = nil
         end
-        print_http(response)
-        data = JSON.parse(response.body, symbolize_names: true) rescue nil
 
         if response.is_a? Net::HTTPTooManyRequests
           raise MatrixRequestError.new_by_code(data, response.code) unless autoretry
@@ -280,43 +320,54 @@ module MatrixSdk
           next
         end
 
-        return MatrixSdk::Response.new self, data if response.is_a? Net::HTTPSuccess
+        if response.is_a? Net::HTTPSuccess
+          unless data
+            logger.error "Received non-parsable data in 200 response; #{response.body.inspect}"
+            raise MatrixConnectionError, response
+          end
+          return MatrixSdk::Response.new self, data
+        end
         raise MatrixRequestError.new_by_code(data, response.code) if data
 
         raise MatrixConnectionError.class_by_code(response.code), response
       end
     end
 
+    # Generate a transaction ID
+    #
+    # @return [String] An arbitrary transaction ID
+    def transaction_id
+      ret = @transaction_id ||= 0
+      @transaction_id = @transaction_id.succ
+      ret
+    end
+
     private
 
-    def print_http(http)
+    def print_http(http, body: true, duration: nil, id: nil)
       return unless logger.debug?
 
       if http.is_a? Net::HTTPRequest
-        dir = '>'
+        dir = "#{id ? id + ' : ' : nil}>"
         logger.debug "#{dir} Sending a #{http.method} request to `#{http.path}`:"
       else
-        dir = '<'
-        logger.debug "#{dir} Received a #{http.code} #{http.message} response:"
+        dir = "#{id ? id + ' : ' : nil}<"
+        logger.debug "#{dir} Received a #{http.code} #{http.message} response:#{duration ? " [#{(duration * 1000).to_i}ms]" : nil}"
       end
       http.to_hash.map { |k, v| "#{k}: #{k == 'authorization' ? '[ REDACTED ]' : v.join(', ')}" }.each do |h|
         logger.debug "#{dir} #{h}"
       end
       logger.debug dir
-      clean_body = JSON.parse(http.body) rescue nil if http.body
-      clean_body.keys.each { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body.is_a? Hash
-      clean_body = clean_body.to_s if clean_body
-      logger.debug "#{dir} #{clean_body.length < 200 ? clean_body : clean_body.slice(0..200) + "... [truncated, #{clean_body.length} Bytes]"}" if clean_body
+      if body
+        clean_body = JSON.parse(http.body) rescue nil if http.body
+        clean_body.keys.each { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body.is_a? Hash
+        clean_body = clean_body.to_s if clean_body
+        logger.debug "#{dir} #{clean_body.length < 200 ? clean_body : clean_body.slice(0..200) + "... [truncated, #{clean_body.length} Bytes]"}" if clean_body
+      end
     rescue StandardError => e
       logger.warn "#{e.class} occured while printing request debug; #{e.message}\n#{e.backtrace.join "\n"}"
     end
 
-    def transaction_id
-      ret = @transaction_id ||= 0
-      @transaction_id = @transaction_id.succ
-      ret
-    end
-
     def api_to_path(api)
       # TODO: <api>_current / <api>_latest
       "/_matrix/#{api.to_s.split('_').join('/')}"

data/lib/matrix_sdk/client.rb

@@ -23,7 +23,7 @@ module MatrixSdk
     attr_reader :api, :next_batch
     attr_accessor :cache, :sync_filter
 
-    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event
+    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event, :state_event
     ignore_inspect :api,
                    :on_event, :on_presence_event, :on_invite_event, :on_leave_event, :on_ephemeral_event
 
@@ -44,7 +44,7 @@ module MatrixSdk
     # @see #initialize
     def self.new_for_domain(domain, **params)
       api = MatrixSdk::Api.new_for_domain(domain, keep_wellknown: true)
-      return new(api, params) unless api.well_known.key? 'm.identity_server'
+      return new(api, params) unless api.well_known&.key?('m.identity_server')
 
       identity_server = MatrixSdk::Api.new(api.well_known['m.identity_server']['base_url'], protocols: %i[IS])
       new(api, params.merge(identity_server: identity_server))
@@ -70,8 +70,6 @@ module MatrixSdk
         @api = Api.new hs_url, params
       end
 
-      @rooms = {}
-      @users = {}
       @cache = client_cache
       @identity_server = nil
 
@@ -79,7 +77,6 @@ module MatrixSdk
       @sync_thread = nil
       @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) }, state: { lazy_load_members: true } } }
 
-      @should_listen = false
       @next_batch = nil
 
       @bad_sync_timeout_limit = 60 * 60
@@ -88,6 +85,11 @@ module MatrixSdk
         instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
       end
 
+      @rooms = {}
+      @room_handlers = {}
+      @users = {}
+      @should_listen = false
+
       raise ArgumentError, 'Cache value must be one of of [:all, :some, :none]' unless %i[all some none].include? @cache
 
       return unless params[:user_id]
@@ -343,7 +345,7 @@ module MatrixSdk
 
     # Joins an already created room
     #
-    # @param room_id_or_alias [String,MXID] A room alias (#room:exmaple.com) or a room ID (!id:example.com)
+    # @param room_id_or_alias [String,MXID] A room alias (#room:example.com) or a room ID (!id:example.com)
     # @param server_name [Array[String]] A list of servers to attempt the join through, required for IDs
     # @return [Room] The resulting room
     # @see Protocols::CS#join_room
@@ -423,7 +425,30 @@ module MatrixSdk
       return if listening?
 
       @should_listen = true
-      thread = Thread.new { listen_forever(params) }
+      if api.protocol?(:MSC) && api.msc2108?
+        params[:filter] = sync_filter unless params.key? :filter
+        params[:filter] = params[:filter].to_json unless params[:filter].nil? || params[:filter].is_a?(String)
+        params[:since] = @next_batch if @next_batch
+
+        errors = 0
+        thread, cancel_token = api.msc2108_sync_sse(params) do |data, event:, id:|
+          @next_batch = id if id
+          if event.to_sym == :sync
+            handle_sync_response(data)
+            errors = 0
+          elsif event.to_sym == :sync_error
+            logger.error "SSE Sync error received; #{data.type}: #{data.message}"
+            errors += 1
+
+            # TODO: Allow configuring
+            raise 'Aborting due to excessive errors' if errors >= 5
+          end
+        end
+
+        @should_listen = cancel_token
+      else
+        thread = Thread.new { listen_forever(params) }
+      end
       @sync_thread = thread
       thread.run
     end
@@ -432,8 +457,15 @@ module MatrixSdk
     def stop_listener_thread
       return unless @sync_thread
 
-      @should_listen = false
-      @sync_thread.join if @sync_thread.alive?
+      if @should_listen.is_a? Hash
+        @should_listen[:run] = false
+      else
+        @should_listen = false
+      end
+      if @sync_thread.alive?
+        ret = @sync_thread.join(2)
+        @sync_thread.kill unless ret
+      end
       @sync_thread = nil
     end
 
@@ -494,9 +526,7 @@ module MatrixSdk
       end
     end
 
-    private
-
-    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 30, **params)
+    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 0, **params)
       orig_bad_sync_timeout = bad_sync_timeout + 0
       while @should_listen
         begin
@@ -519,6 +549,8 @@ module MatrixSdk
       fire_error(ErrorEvent.new(e, :listener_thread))
     end
 
+    private
+
     def post_authentication(data)
       @mxid = data[:user_id]
       @api.access_token = data[:access_token]
@@ -530,7 +562,10 @@ module MatrixSdk
     def handle_state(room_id, state_event)
       return unless state_event.key? :type
 
+      on_state_event.fire(MatrixEvent.new(self, state_event), state_event[:type])
+
       room = ensure_room(room_id)
+      room.send :put_state_event, state_event
       content = state_event[:content]
       case state_event[:type]
       when 'm.room.name'
@@ -544,9 +579,9 @@ module MatrixSdk
       when 'm.room.aliases'
         room.instance_variable_get('@aliases').concat content[:aliases]
       when 'm.room.join_rules'
-        room.instance_variable_set '@join_rule', content[:join_rule].to_sym
+        room.instance_variable_set '@join_rule', content[:join_rule].nil? ? nil : content[:join_rule].to_sym
       when 'm.room.guest_access'
-        room.instance_variable_set '@guest_access', content[:guest_access].to_sym
+        room.instance_variable_set '@guest_access', content[:guest_access].nil? ? nil : content[:guest_access].to_sym
       when 'm.room.member'
         return unless cache == :all
 
@@ -587,7 +622,12 @@ module MatrixSdk
 
         join[:timeline][:events].each do |event|
           event[:room_id] = room_id.to_s
-          handle_state(room_id, event) unless event[:type] == 'm.room.message'
+          # 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] }
+
+            handle_state(room_id, event) unless event == state_event
+          end
           room.send :put_event, event
 
           fire_event(MatrixEvent.new(self, event), event[:type])

data/lib/matrix_sdk/extensions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module URI
   # A mxc:// Matrix content URL
   class MATRIX < Generic

data/lib/matrix_sdk/mxid.rb

@@ -10,6 +10,7 @@ module MatrixSdk
       raise ArgumentError, 'Identifier is too long' if identifier.size > 255
       raise ArgumentError, 'Identifier lacks required data' unless identifier =~ %r{^([@!$+#][^:]+:[^:]+(?::\d+)?)|(\$[A-Za-z0-9+/]+)$}
 
+      # 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(':')
       @port = @port.to_i if @port

data/lib/matrix_sdk/protocols/cs.rb

@@ -1637,7 +1637,7 @@ module MatrixSdk::Protocols::CS
 
     room_id = ERB::Util.url_encode room_id.to_s
 
-    request(:get, :client_r0, "/rooms/#{room_id}/members", query: query)
+    request(:get, :client_r0, "/rooms/#{room_id}/members", query: query.merge(params))
   end
 
   # Gets a list of the joined members in a room
@@ -1823,7 +1823,7 @@ module MatrixSdk::Protocols::CS
   # @see https://matrix.org/docs/spec/client_server/latest#get-matrix-client-r0-pushrules
   #      The Matrix Spec, for more information about the parameters and data
   def get_pushrules
-    request(:get, :client_r0, '/pushrules')
+    request(:get, :client_r0, '/pushrules/')
   end
 
   # Retrieves a single registered push rule for the current user

data/lib/matrix_sdk/protocols/msc.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# Preliminary support for unmerged MSCs (Matrix Spec Changes)
+module MatrixSdk::Protocols::MSC
+  def refresh_mscs
+    @msc = {}
+  end
+
+  # Check if there's support for MSC2108 - Sync over Server Sent Events
+  def msc2108?
+    @msc ||= {}
+    @msc[2108] ||= \
+      begin
+        request(:get, :client_r0, '/sync/sse', skip_auth: true, headers: { accept: 'text/event-stream' })
+      rescue MatrixSdk::MatrixNotAuthorizedError # Returns 401 if implemented
+        true
+      rescue MatrixSdk::MatrixRequestError
+        false
+      end
+  rescue StandardError => e
+    logger.debug "Failed to check MSC2108 status;\n#{e.inspect}"
+    false
+  end
+
+  # Sync over Server Sent Events - MSC2108
+  #
+  # @example Syncing over SSE
+  #   @since = 'some token'
+  #   api.msc2108_sync_sse(since: @since) do |data, event:, id:|
+  #     if event == 'sync'
+  #       handle(data) # data is the same as a normal sync response
+  #       @since = id
+  #     end
+  #   end
+  #
+  # @see Protocols::CS#sync
+  # @see https://github.com/matrix-org/matrix-doc/pull/2108/
+  # rubocop:disable Metrics/MethodLength
+  def msc2108_sync_sse(since: nil, **params, &on_data)
+    raise ArgumentError, 'Must be given a block accepting two args - data and { event:, id: }' \
+      unless on_data.is_a?(Proc) && on_data.arity == 2
+    raise 'Needs to be logged in' unless access_token # TODO: Better error
+
+    query = params.select do |k, _v|
+      %i[filter full_state set_presence].include? k
+    end
+    query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)
+
+    req = Net::HTTP::Get.new(homeserver.dup.tap do |u|
+      u.path = api_to_path(:client_r0) + '/sync/sse'
+      u.query = URI.encode_www_form(query)
+    end)
+    req['accept'] = 'text/event-stream'
+    req['accept-encoding'] = 'identity' # Disable compression on the SSE stream
+    req['authorization'] = "Bearer #{access_token}"
+    req['last-event-id'] = since if since
+
+    cancellation_token = { run: true }
+
+    # rubocop:disable Metrics/BlockLength
+    thread = Thread.new(cancellation_token) do |ctx|
+      print_http(req)
+      http.request req do |response|
+        break unless ctx[:run]
+
+        print_http(response, body: false)
+        raise MatrixRequestError.new_by_code(JSON.parse(response.body, symbolize_names: true), response.code) unless response.is_a? Net::HTTPSuccess
+
+        # Override buffer size for BufferedIO
+        socket = response.instance_variable_get :@socket
+        if socket.is_a? Net::BufferedIO
+          socket.instance_eval do
+            def rbuf_fill
+              bufsize_override = 1024
+              loop do
+                case rv = @io.read_nonblock(bufsize_override, exception: false)
+                when String
+                  @rbuf << rv
+                  rv.clear
+                  return
+                when :wait_readable
+                  @io.to_io.wait_readable(@read_timeout) || raise(Net::ReadTimeout)
+                when :wait_writable
+                  @io.to_io.wait_writable(@read_timeout) || raise(Net::ReadTimeout)
+                when nil
+                  raise EOFError, 'end of file reached'
+                end
+              end
+            end
+          end
+        end
+
+        stream_id = ('A'..'Z').to_a.sample(4).join
+
+        logger.debug "MSC2108 : #{stream_id} : Starting SSE stream."
+
+        buffer = ''
+        response.read_body do |chunk|
+          buffer += chunk
+
+          while (index = buffer.index(/\r\n\r\n|\n\n/))
+            stream = buffer.slice!(0..index)
+
+            data = ''
+            event = nil
+            id = nil
+
+            stream.split(/\r?\n/).each do |part|
+              /^data:(.+)$/.match(part) do |m_data|
+                data += "\n" unless data.empty?
+                data += m_data[1].strip
+              end
+              /^event:(.+)$/.match(part) do |m_event|
+                event = m_event[1].strip
+              end
+              /^id:(.+)$/.match(part) do |m_id|
+                id = m_id[1].strip
+              end
+              /^:(.+)$/.match(part) do |m_comment|
+                logger.debug "MSC2108 : #{stream_id} : Received comment '#{m_comment[1].strip}'"
+              end
+            end
+
+            if %w[sync sync_error].include? event
+              data = JSON.parse(data, symbolize_names: true)
+              yield((MatrixSdk::Response.new self, data), event: event, id: id)
+            elsif event
+              logger.info "MSC2108 : #{stream_id} : Received unknown event '#{event}'; #{data}"
+            end
+          end
+
+          unless ctx[:run]
+            socket.close
+            break
+          end
+        end
+        break unless ctx[:run]
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    thread.run
+
+    [thread, cancellation_token]
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/matrix_sdk/room.rb

@@ -42,19 +42,11 @@ module MatrixSdk
     #        The timeline events are what will end up in here
     attr_reader :id, :client, :topic, :aliases, :members, :events
 
-    # @!attribute [r] on_event
-    #   @return [EventHandlerArray] The list of event handlers for all events
-    # @!attribute [r] on_state_event
-    #   @return [EventHandlerArray] The list of event handlers for only state events
-    # @!attribute [r] on_ephemeral_event
-    #   @return [EventHandlerArray] The list of event handlers for only ephemeral events
-    events :event, :state_event, :ephemeral_event
     # @!method inspect
     #   An inspect method that skips a handful of instance variables to avoid
     #   flooding the terminal with debug data.
     #   @return [String] a regular inspect string without the data for some variables
-    ignore_inspect :client, :members, :events, :prev_batch, :logger,
-                   :on_event, :on_state_event, :on_ephemeral_event
+    ignore_inspect :client, :members, :events, :prev_batch, :logger
 
     alias room_id id
 
@@ -85,8 +77,6 @@ module MatrixSdk
       room_id = MXID.new room_id unless room_id.is_a?(MXID)
       raise ArgumentError, 'room_id must be a valid Room ID' unless room_id.room_id?
 
-      event_initialize
-
       @name = nil
       @topic = nil
       @canonical_alias = nil
@@ -114,6 +104,30 @@ module MatrixSdk
       logger.debug "Created room #{room_id}"
     end
 
+
+    #
+    # Event handlers
+    #
+
+    # @!attribute [r] on_event
+    #   @return [EventHandlerArray] The list of event handlers for all events
+    def on_event
+      ensure_room_handlers[:event]
+    end
+
+    # @!attribute [r] on_state_event
+    #   @return [EventHandlerArray] The list of event handlers for only state events
+    def on_state_event
+      ensure_room_handlers[:state_event]
+    end
+
+    # @!attribute [r] on_ephemeral_event
+    #   @return [EventHandlerArray] The list of event handlers for only ephemeral events
+    def on_ephemeral_event
+      ensure_room_handlers[:ephemeral_event]
+    end
+
+
     #
     # State readers
     #
@@ -157,6 +171,17 @@ module MatrixSdk
       members
     end
 
+    # Get all members (member events) in the room
+    #
+    # @note This will also count members who've knocked, been invited, have left, or have been banned.
+    #
+    # @param params [Hash] Additional query parameters to pass to the room member listing - e.g. for filtering purposes.
+    #
+    # @return [Array(User)] The complete list of members in the room, regardless of membership state
+    def all_members(**params)
+      client.api.get_room_members(id, **params)[:chunk].map { |ch| client.get_user(ch[:state_key]) }
+    end
+
     # Gets the current name of the room, querying the API if necessary
     #
     # @note Will cache the current name for 15 minutes
@@ -512,10 +537,10 @@ module MatrixSdk
     # @return [Boolean] if the name was changed or not
     def reload_name!
       data = begin
-               client.api.get_room_name(id)
-             rescue MatrixNotFoundError
-               nil
-             end
+        client.api.get_room_name(id)
+      rescue MatrixNotFoundError
+        nil
+      end
       changed = data[:name] != @name
       @name = data[:name] if changed
       changed
@@ -535,10 +560,10 @@ module MatrixSdk
     # @return [Boolean] if the topic was changed or not
     def reload_topic!
       data = begin
-               client.api.get_room_topic(id)
-             rescue MatrixNotFoundError
-               nil
-             end
+        client.api.get_room_topic(id)
+      rescue MatrixNotFoundError
+        nil
+      end
       changed = data[:topic] != @topic
       @topic = data[:topic] if changed
       changed
@@ -590,7 +615,7 @@ module MatrixSdk
     #
     # @param join_rule [:invite,:public] The join rule of the room
     def join_rule=(join_rule)
-      client.api.set_join_rule(id, join_rule)
+      client.api.set_room_join_rules(id, join_rule)
       @join_rule = join_rule
     end
 
@@ -606,7 +631,7 @@ module MatrixSdk
     #
     # @param guest_access [:can_join,:forbidden] The new guest access status of the room
     def guest_access=(guest_access)
-      client.api.set_guest_access(id, guest_access)
+      client.api.set_room_guest_access(id, guest_access)
       @guest_access = guest_access
     end
 
@@ -670,15 +695,35 @@ module MatrixSdk
       members << member unless members.any? { |m| m.id == member.id }
     end
 
+    def room_handlers?
+      client.instance_variable_get(:@room_handlers).key? id
+    end
+
+    def ensure_room_handlers
+      client.instance_variable_get(:@room_handlers)[id] ||= {
+        event: MatrixSdk::EventHandlerArray.new,
+        state_event: MatrixSdk::EventHandlerArray.new,
+        ephemeral_event: MatrixSdk::EventHandlerArray.new
+      }
+    end
+
     def put_event(event)
+      ensure_room_handlers[:event].fire(MatrixEvent.new(self, event), event[:type]) if room_handlers?
+
       @events.push event
       @events.shift if @events.length > @event_history_limit
-
-      fire_event MatrixEvent.new(self, event)
     end
 
     def put_ephemeral_event(event)
-      fire_ephemeral_event MatrixEvent.new(self, event)
+      return unless room_handlers?
+
+      ensure_room_handlers[:ephemeral_event].fire(MatrixEvent.new(self, event), event[:type])
+    end
+
+    def put_state_event(event)
+      return unless room_handlers?
+
+      ensure_room_handlers[:state_event].fire(MatrixEvent.new(self, event), event[:type])
     end
   end
 end

data/lib/matrix_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MatrixSdk
-  VERSION = '2.0.0'
+  VERSION = '2.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: matrix_sdk
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.3
 platform: ruby
 authors:
 - Alexander Olofsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-14 00:00:00.000000000 Z
+date: 2020-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
@@ -103,6 +103,7 @@ files:
 - lib/matrix_sdk/protocols/as.rb
 - lib/matrix_sdk/protocols/cs.rb
 - lib/matrix_sdk/protocols/is.rb
+- lib/matrix_sdk/protocols/msc.rb
 - lib/matrix_sdk/protocols/ss.rb
 - lib/matrix_sdk/response.rb
 - lib/matrix_sdk/room.rb