mtproto 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2744b720c59f90c3e9d18021ce6096a1c8e559dae949fbd6a9b53948c14f8b5c
-  data.tar.gz: 3b9000cabc247db305244b279bc58474466e1549cca3efa07ca1202eaa2d7874
+  metadata.gz: 93bf74e47e4eb9cea99def85727f559cc3fcbe484411ba181b6ac596ed24fcbe
+  data.tar.gz: c0b1bc2e59a38eb2042d938692ba1959bbad1633a0594858ce9c1991444f4ef0
 SHA512:
-  metadata.gz: 874a17be8f75bb305057d0a0cb2c136441f9e8da883c44a99169ad0975c5b745b4323abc84ab6edb96b72f2c8f500ec40536a1a6724f585730501514a2e7475b
-  data.tar.gz: 6a693436a7443f789cb73a6fe6ecebf523ee288bb174b297fdfac4274340c9a5a00544299d08f0558028645e4cf80dbfb0c70c844ec47d2bb6e413589a45a5b2
+  metadata.gz: 9a5cd8f10a36c676db3ba4e642f9f7d1a209600278b3d571c86dfcf78f489613603919a8c1f950b8e3b71e2a1a721a4b0fab721b2e318eb30ff7960edfe6b4df
+  data.tar.gz: e98baafabd0e49ea34d1cc7d92b6761a1b899fec53c19faccd96ada01989b8784ac6114e597f28a1f0a15f34ed95cb600948f89decdee66c0d84c6ec1e716194

data/.env.example

@@ -3,3 +3,7 @@ TG_API_HASH=your_api_hash
 TG_TEST_DC='111.111.111.111:443'
 TG_TEST_DC_N='1'
 TG_TEST_DC_KEY='DC public key'
+
+# For integration tests with authentication:
+TG_AUTH='auth data 1'
+TG_AUTH_2='auth data 2'

data/lib/mtproto/async/middleware/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Async
+    module Middleware
+      class Base
+        def initialize(app)
+          @app = app
+        end
+
+        def call(request, future, retry_fn, retries)
+          @app.call(request, future, retry_fn, retries)
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/async/middleware/flood_wait.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module MTProto
+  module Async
+    module Middleware
+      class FloodWait < Base
+        def initialize(app, max_retries: 5)
+          super(app)
+          @max_retries = max_retries
+        end
+
+        def call(request, future, retry_fn, retries)
+          wrapped = @app.call(request, future, retry_fn, retries)
+
+          wrapped.rescue do |error|
+            if flood_wait_error?(error) && retries < @max_retries
+              delay = extract_delay(error.error_message)
+              sleep(delay)
+              retry_fn.call.value!
+            else
+              raise error
+            end
+          end
+        end
+
+        private
+
+        def flood_wait_error?(error)
+          error.is_a?(MTProto::RpcError) &&
+            error.error_code == 420 &&
+            error.error_message.start_with?('FLOOD_WAIT_')
+        end
+
+        def extract_delay(error_message)
+          error_message[11..-1].to_i
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/async/request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Async
+    class Request
+      attr_reader :body, :metadata
+
+      def initialize(body:, metadata: {})
+        @body = body
+        @metadata = metadata
+      end
+
+      def key
+        metadata[:key] || :default
+      end
+    end
+  end
+end

data/lib/mtproto/async/request_queue.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module MTProto
+  module Async
+    class RequestQueue
+      def initialize
+        @queues = Concurrent::Hash.new
+        @threads = Concurrent::Hash.new
+        @running = Concurrent::AtomicBoolean.new(true)
+      end
+
+      def call(key:, &blk)
+        ensure_worker_running!(key)
+
+        future = Concurrent::Promises.resolvable_future
+        @queues[key] << [blk, future]
+        future
+      end
+
+      def shutdown
+        @running.make_false
+        @threads.each_value do |thread|
+          thread.join(2)
+          thread.kill if thread.alive?
+        end
+        @threads.clear
+        @queues.clear
+      end
+
+      private
+
+      def ensure_worker_running!(key)
+        return if @threads.key?(key) && @threads[key].alive?
+
+        @queues[key] ||= Queue.new
+        @threads[key] = Thread.new { worker_loop(key) }
+      end
+
+      def worker_loop(key)
+        queue = @queues[key]
+        loop do
+          break unless @running.true?
+
+          begin
+            blk, future = queue.pop(true)
+            result = blk.call
+            if result.is_a?(Concurrent::Promises::Future)
+              result.then { |v| future.fulfill(v) }.rescue { |e| future.reject(e) }
+            else
+              future.fulfill(result)
+            end
+          rescue ThreadError
+            sleep 0.01
+          rescue => e
+            future&.reject(e) if future
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/async_client.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require_relative 'async/request'
+require_relative 'async/request_queue'
+require_relative 'async/middleware/base'
+require_relative 'async/middleware/flood_wait'
+
+module MTProto
+  class AsyncClient
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+      @queue = Async::RequestQueue.new
+      @middleware_classes = []
+      @pending_requests = Concurrent::Hash.new
+      @timeout_threads = Concurrent::Hash.new
+      @receiver_thread = nil
+      @running = Concurrent::AtomicBoolean.new(false)
+
+      use(Async::Middleware::FloodWait)
+    end
+
+    def use(middleware_class, **options)
+      @middleware_classes << [middleware_class, options]
+      self
+    end
+
+    def call(body, metadata: {})
+      ensure_receiver_running!
+
+      request = Async::Request.new(body: body, metadata: metadata)
+
+      @queue.call(key: request.key) do
+        send_and_wrap = lambda do |retries = 0|
+          base_future = send_request(request.body)
+
+          retry_fn = lambda do
+            send_and_wrap.call(retries + 1)
+          end
+
+          build_middleware_stack.call(request, base_future, retry_fn, retries)
+        end
+
+        send_and_wrap.call(0)
+      end
+    end
+
+    def shutdown
+      @running.make_false
+
+      @client.disconnect! if @client.connected?
+
+      if @receiver_thread
+        @receiver_thread.join(2)
+        @receiver_thread.kill if @receiver_thread.alive?
+        @receiver_thread = nil
+      end
+
+      @timeout_threads.each_value(&:kill)
+      @timeout_threads.clear
+
+      @pending_requests.each_value do |future|
+        future.reject(MTProto::Transport::ConnectionError.new('Client shutting down')) unless future.resolved?
+      end
+      @pending_requests.clear
+
+      @queue.shutdown
+    end
+
+    private
+
+    def send_request(body)
+      msg_id = @client.rpc.call(body)
+      future = Concurrent::Promises.resolvable_future
+      @pending_requests[msg_id] = future
+
+      timeout_thread = Thread.new do
+        sleep @client.timeout
+        if @pending_requests.delete(msg_id)
+          future.reject(MTProto::Transport::ConnectionError.new('RPC timeout'))
+        end
+        @timeout_threads.delete(msg_id)
+      end
+      @timeout_threads[msg_id] = timeout_thread
+
+      future.on_fulfillment! do
+        timeout_thread.kill
+        @timeout_threads.delete(msg_id)
+      end
+      future.on_rejection! do
+        timeout_thread.kill
+        @timeout_threads.delete(msg_id)
+      end
+
+      future
+    end
+
+    def ensure_receiver_running!
+      return if @running.true?
+
+      @running.make_true
+      @receiver_thread = Thread.new { receiver_loop }
+    end
+
+    def receiver_loop
+      loop do
+        break unless @running.true?
+
+        begin
+          response_data = @client.connection.recv(timeout: 1)
+
+          decrypted = EncryptedMessage.decrypt(
+            auth_key: @client.auth_key,
+            encrypted_message_data: response_data,
+            sender: :server
+          )
+
+          process_message(decrypted[:body])
+        rescue MTProto::Transport::ConnectionError => e
+          next if e.message == 'Receive timeout' && @running.true?
+          break
+        rescue IOError => e
+          break
+        rescue => e
+          warn "AsyncClient receiver error: #{e.class}: #{e.message}"
+          warn e.backtrace.join("\n")
+          break
+        end
+      end
+    end
+
+    def process_message(response_body)
+      constructor = response_body[0, 4].unpack1('L<')
+
+      case constructor
+      when Client::RPC::CONSTRUCTOR_BAD_SERVER_SALT
+        handle_bad_server_salt(response_body)
+      when Type::NewSessionCreated::CONSTRUCTOR
+        handle_new_session(response_body)
+      when Type::MsgContainer::CONSTRUCTOR
+        handle_container(response_body)
+      when Client::RPC::CONSTRUCTOR_RPC_RESULT
+        handle_rpc_result(response_body)
+      end
+    end
+
+    def handle_bad_server_salt(response_body)
+      offset = 4
+      offset += 8
+      offset += 4
+      offset += 4
+      new_server_salt = response_body[offset, 8].unpack1('Q<')
+
+      @client.instance_variable_set(:@server_salt, new_server_salt)
+    end
+
+    def handle_new_session(response_body)
+      session_info = Type::NewSessionCreated.deserialize(response_body)
+      @client.instance_variable_set(:@server_salt, session_info.server_salt)
+    end
+
+    def handle_container(response_body)
+      container = Type::MsgContainer.deserialize(response_body)
+
+      container.messages.each do |msg|
+        process_message(msg[:body])
+      end
+    end
+
+    def handle_rpc_result(response_body)
+      offset = 4
+      req_msg_id = response_body[offset, 8].unpack1('Q<')
+      offset += 8
+      result = response_body[offset..]
+
+      future = @pending_requests.delete(req_msg_id)
+      return unless future  # No pending request for this msg_id
+
+      # Check if result is an RPC error
+      result_constructor = result[0, 4].unpack1('L<')
+      if result_constructor == Type::RpcError::CONSTRUCTOR
+        error = Type::RpcError.deserialize(result)
+        future.reject(MTProto::RpcError.new(error.error_code, error.error_message))
+      else
+        future.fulfill(result)
+      end
+    end
+
+    def build_middleware_stack
+      # Middleware now wraps Futures and can trigger retries
+      # The base "app" just returns the Future as-is
+      app = ->(request, future, retry_fn, retries) { future }
+
+      @middleware_classes.reverse.reduce(app) do |stack, (middleware_class, options)|
+        middleware_class.new(stack, **options)
+      end
+    end
+  end
+end

data/lib/mtproto/auth_key_generator.rb

@@ -3,12 +3,12 @@
 require 'securerandom'
 require 'digest'
 require_relative 'message_id'
-require_relative 'tl/auth_key/req_pq_multi'
-require_relative 'tl/auth_key/res_pq'
-require_relative 'tl/auth_key/req_dh_params'
-require_relative 'tl/auth_key/server_dh_params'
-require_relative 'tl/auth_key/set_client_dh_params'
-require_relative 'tl/auth_key/dh_gen_response'
+require_relative 'type/auth_key/req_pq_multi'
+require_relative 'type/auth_key/res_pq'
+require_relative 'type/auth_key/req_dh_params'
+require_relative 'type/auth_key/server_dh_params'
+require_relative 'type/auth_key/set_client_dh_params'
+require_relative 'type/auth_key/dh_gen_response'
 
 module MTProto
   class AuthKeyGenerator
@@ -87,13 +87,13 @@ module MTProto
 
     def req_pq_multi
       nonce = SecureRandom.random_bytes(16)
-      body = TL::AuthKey::ReqPqMulti.build(nonce)
-      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
+      body = Type::AuthKey::ReqPqMulti.build(nonce)
+      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
-      response_message = TL::Message.deserialize(response_data)
-      res_pq = TL::AuthKey::ResPq.parse(response_message.body)
+      response_message = Type::Message.deserialize(response_data)
+      res_pq = Type::AuthKey::ResPq.parse(response_message.body)
 
       raise 'Nonce mismatch!' unless res_pq[:nonce] == nonce
 
@@ -114,7 +114,7 @@ module MTProto
       # For production DCs, use the DC number as-is
       dc_value = @test_mode ? (@dc_number + 10000) : @dc_number
 
-      inner_data = TL::PQInnerData.new(
+      inner_data = Type::PQInnerData.new(
         pq: Crypto::Factorization.bytes_to_integer(res_pq[:pq]),
         p: p,
         q: q,
@@ -128,7 +128,7 @@ module MTProto
     end
 
     def send_req_dh_params(res_pq, p, q, server_key, encrypted_data)
-      body = TL::AuthKey::ReqDHParams.build(
+      body = Type::AuthKey::ReqDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         p: p,
@@ -136,13 +136,13 @@ module MTProto
         public_key_fingerprint: server_key.fingerprint,
         encrypted_data: encrypted_data
       )
-      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
+      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
-      response_message = TL::Message.deserialize(response_data)
-      server_dh_params = TL::AuthKey::ServerDHParams.parse(response_message.body)
+      response_message = Type::Message.deserialize(response_data)
+      server_dh_params = Type::AuthKey::ServerDHParams.parse(response_message.body)
 
       raise 'Nonce mismatch!' unless server_dh_params[:nonce] == res_pq[:nonce]
       raise 'Server nonce mismatch!' unless server_dh_params[:server_nonce] == res_pq[:server_nonce]
@@ -172,7 +172,7 @@ module MTProto
         answer = answer[0..-2]
       end
 
-      server_dh_inner_data = TL::ServerDHInnerData.deserialize(answer)
+      server_dh_inner_data = Type::ServerDHInnerData.deserialize(answer)
 
       raise 'Nonce mismatch in DH inner data!' unless server_dh_inner_data.nonce == res_pq[:nonce]
       raise 'Server nonce mismatch in DH inner data!' unless server_dh_inner_data.server_nonce == res_pq[:server_nonce]
@@ -181,7 +181,7 @@ module MTProto
     end
 
     def send_client_dh_params(res_pq, new_nonce, client_dh_params, tmp_aes_key, tmp_aes_iv)
-      client_dh_inner_data = TL::ClientDHInnerData.new(
+      client_dh_inner_data = Type::ClientDHInnerData.new(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         retry_id: 0,
@@ -200,18 +200,18 @@ module MTProto
         tmp_aes_iv
       )
 
-      body = TL::AuthKey::SetClientDHParams.build(
+      body = Type::AuthKey::SetClientDHParams.build(
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         encrypted_data: client_dh_encrypted
       )
-      message = TL::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
+      message = Type::Message.new(auth_key_id: 0, msg_id: MessageId.generate, body: body)
 
       @connection.send(message.serialize)
 
       response_data = @connection.recv(timeout: @timeout)
-      response_message = TL::Message.deserialize(response_data)
-      TL::AuthKey::DHGenResponse.parse(response_message.body)
+      response_message = Type::Message.deserialize(response_data)
+      Type::AuthKey::DHGenResponse.parse(response_message.body)
     end
 
     def verify_dh_gen_response(dh_gen_response, res_pq, new_nonce, auth_key)

data/lib/mtproto/client/rpc.rb

@@ -32,6 +32,27 @@ module MTProto
 
         @client.connection.send(encrypted_msg.serialize)
 
+        msg_id
+      end
+
+      def call_sync(body, content_related: true)
+        raise 'Auth key not generated' unless @client.auth_key
+        raise 'Session not initialized' unless @client.session
+
+        msg_id = MessageId.generate(time_offset: @client.time_offset)
+        seq_no = @client.session.next_seq_no(content_related: content_related)
+
+        encrypted_msg = EncryptedMessage.encrypt(
+          auth_key: @client.auth_key,
+          server_salt: @client.server_salt,
+          session_id: @client.session.session_id,
+          msg_id: msg_id,
+          seq_no: seq_no,
+          body: body
+        )
+
+        @client.connection.send(encrypted_msg.serialize)
+
         response_data = @client.connection.recv(timeout: @client.timeout)
 
         decrypted = EncryptedMessage.decrypt(
@@ -44,25 +65,19 @@ module MTProto
 
         constructor = response_body[0, 4].unpack1('L<')
 
-        # Handle bad_server_salt
         if constructor == CONSTRUCTOR_BAD_SERVER_SALT
-          # bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long
           offset = 4
-          bad_msg_id = response_body[offset, 8].unpack1('Q<')
           offset += 8
-          bad_msg_seqno = response_body[offset, 4].unpack1('L<')
           offset += 4
-          error_code = response_body[offset, 4].unpack1('L<')
           offset += 4
           new_server_salt = response_body[offset, 8].unpack1('Q<')
 
-          # Update server salt and retry
           update_server_salt(new_server_salt)
-          return call(body, content_related: content_related)
+          return call_sync(body, content_related: content_related)
         end
 
-        if constructor == TL::NewSessionCreated::CONSTRUCTOR
-          session_info = TL::NewSessionCreated.deserialize(response_body)
+        if constructor == Type::NewSessionCreated::CONSTRUCTOR
+          session_info = Type::NewSessionCreated.deserialize(response_body)
           update_server_salt(session_info.server_salt)
 
           response_data = @client.connection.recv(timeout: @client.timeout)
@@ -75,26 +90,26 @@ module MTProto
           constructor = response_body[0, 4].unpack1('L<')
         end
 
-        if constructor == TL::MsgContainer::CONSTRUCTOR
-          container = TL::MsgContainer.deserialize(response_body)
+        if constructor == Type::MsgContainer::CONSTRUCTOR
+          container = Type::MsgContainer.deserialize(response_body)
 
           rpc_result = container.messages.find do |msg|
             msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
           end
 
-          return rpc_result[:body][12..] if rpc_result
+          return extract_rpc_result(rpc_result[:body][12..]) if rpc_result
 
           new_session = container.messages.find do |msg|
-            msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR
+            msg[:body][0, 4].unpack1('L<') == Type::NewSessionCreated::CONSTRUCTOR
           end
           if new_session
-            session_info = TL::NewSessionCreated.deserialize(new_session[:body])
+            session_info = Type::NewSessionCreated.deserialize(new_session[:body])
             update_server_salt(session_info.server_salt)
 
             other_messages = container.messages.reject do |msg|
               constructor = msg[:body][0, 4].unpack1('L<')
               (
-                constructor == TL::NewSessionCreated::CONSTRUCTOR ||
+                constructor == Type::NewSessionCreated::CONSTRUCTOR ||
                 constructor == CONSTRUCTOR_MSGS_ACK
               )
             end
@@ -110,14 +125,14 @@ module MTProto
             response_body = decrypted[:body]
             constructor = response_body[0, 4].unpack1('L<')
 
-            return response_body[12..] if constructor == CONSTRUCTOR_RPC_RESULT
+            return extract_rpc_result(response_body[12..]) if constructor == CONSTRUCTOR_RPC_RESULT
 
-            if constructor == TL::MsgContainer::CONSTRUCTOR
-              container = TL::MsgContainer.deserialize(response_body)
+            if constructor == Type::MsgContainer::CONSTRUCTOR
+              container = Type::MsgContainer.deserialize(response_body)
               rpc_result = container.messages.find do |msg|
                 msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_RPC_RESULT
               end
-              return rpc_result[:body][12..] if rpc_result
+              return extract_rpc_result(rpc_result[:body][12..]) if rpc_result
             end
 
             return response_body
@@ -126,13 +141,22 @@ module MTProto
           return container.messages.first[:body]
         end
 
-        return response_body[12..] if constructor == CONSTRUCTOR_RPC_RESULT
+        return extract_rpc_result(response_body[12..]) if constructor == CONSTRUCTOR_RPC_RESULT
 
         response_body
       end
 
       private
 
+      def extract_rpc_result(result)
+        result_constructor = result[0, 4].unpack1('L<')
+        if result_constructor == Type::RpcError::CONSTRUCTOR
+          error = Type::RpcError.deserialize(result)
+          raise MTProto::RpcError.new(error.error_code, error.error_message)
+        end
+        result
+      end
+
       def update_server_salt(server_salt)
         @client.instance_variable_set(:@server_salt, server_salt)
       end