matrix_sdk 2.4.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8fabc9c9f840753916f52925807e2b6282a9fd17fbeedd63f284bd60a1aab86
-  data.tar.gz: d0c2330e13f85036bbc0cecf1cde73fc2b960906c497b0cb7fdfe89b49499fd8
+  metadata.gz: 7db96470aa545490e2dc289243a1c133a708548e334748fee72cfa1bdba68543
+  data.tar.gz: 863bf01f82c86e9a6329bb505c727a872bf2f2b7b5dd8f51fbc633d74675d8b6
 SHA512:
-  metadata.gz: 709c402251e87cd3cb650a7081d121eda551fec86f46dde8c92f2799491810ddb16bd8e44280ced09c0a5daa343385958d8ab19640348cffc2f97eafcb14bcaf
-  data.tar.gz: 979fc101ef76e21023b9a6ce41649c0d144a2376429ff3ff6572b0384298d598a30f05ac64e0b2e98013180e7e4b0356a26da214df28ada4c5808e8ae02af331
+  metadata.gz: f529e7679bd36fcad10184795d78f5dd0a72b0a496fe5f3a10d976d3a33e033cf2367ffb01b68bca3e0844ed91f496921a28e2ef7b20a5bd9589c21bb28a321e
+  data.tar.gz: e32d7dcbff2eac544e25f5c7598ac5f743e60dab8eac6394d1054a118882b0efdb3a69dca8ac93d1fae6ed6cf5912d6576156c3dcc9541c0b8b37bc6f9507600

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 2.7.0 - 2022-08-12
+
+- Adds a bot subsystem + DSL 
+  - [An example](examples/bot_api.rb) can be found in the examples folder
+- Adds additional useful helpers for Room and User
+- Fixes Client.new_for_domain
+- Improves the handling of MXIDs as strings
+- Improves handling of caches for rooms
+- Improves Client shutdown when using Client#start_listener_thread
+- Improves account data handling, with caches on both Client and Room level
+
+## 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

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'
@@ -24,7 +26,7 @@ api.request :get, :federation_v1, '/version'
 ```
 
 ```ruby
-# Client wrapper
+# Client wrapper with login
 require 'matrix_sdk'
 
 client = MatrixSdk::Client.new 'https://example.com'
@@ -41,7 +43,7 @@ hq.send_text "This is an example message - don't actually do this ;)"
 ```
 
 ```ruby
-# Client wrapper
+# Client wrapper with token
 require 'matrix_sdk'
 
 client = MatrixSdk::Client.new 'https://example.com'
@@ -56,6 +58,19 @@ client.rooms.count
 # => 5
 ```
 
+```ruby
+#!/bin/env ruby
+# Bot DSL
+require 'matrix_sdk/bot'
+
+command :plug do
+  room.send_text <<~PLUG
+    The Ruby SDK is a fine method for writing applications communicating over the Matrix protocol.
+    It can easily be integrated with Rails, and it supports most client/bot use-cases.
+  PLUG
+end
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ananace/ruby-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,13 +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
+      @inflight = []
+
+      self.threadsafe = params.fetch(:threadsafe, :multithread)
 
       ([params.fetch(:protocols, [:CS])].flatten - protocols).each do |proto|
         self.class.include MatrixSdk::Protocols.const_get(proto)
@@ -243,6 +249,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,14 +298,27 @@ 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
+          @inflight << loc_http
           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
+        ensure
+          @inflight.delete loc_http
+        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)
 
@@ -330,6 +360,10 @@ module MatrixSdk
       ret
     end
 
+    def stop_inflight
+      @inflight.each(&:finish)
+    end
+
     private
 
     def construct_request(method:, url:, **options)
@@ -392,18 +426,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