mtproto 0.0.8 → 0.0.9

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

@@ -1,17 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

@@ -1,201 +0,0 @@
-# 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/rpc/get_config.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/help/get_config'
-require_relative '../type/rpc/help/config'
-
-module MTProto
-  module RPC
-    class GetConfig
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        query = build_query
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        query = build_query
-
-        response = @client.rpc.call_sync(query)
-
-        Type::RPC::Help::Config.parse(response)
-      end
-
-      private
-
-      def build_query
-        Type::RPC::Help::GetConfig.build
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_contacts.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/contacts/get_contacts'
-require_relative '../type/rpc/contacts/contacts'
-
-module MTProto
-  module RPC
-    class GetContacts
-      def initialize(client)
-        @client = client
-      end
-
-      def call(hash: 0)
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
-        @client.rpc.call(query)
-      end
-
-      def call_sync(hash: 0)
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Contacts::Contacts.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_updates_difference.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/updates/get_difference'
-require_relative '../type/rpc/updates/difference'
-
-module MTProto
-  module RPC
-    class GetUpdatesDifference
-      def initialize(client)
-        @client = client
-      end
-
-      def call(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'pts is required' if pts.nil?
-        raise ArgumentError, 'date is required' if date.nil?
-        raise ArgumentError, 'qts is required' if qts.nil?
-
-        query = Type::RPC::Updates::GetDifference.build(
-          pts: pts,
-          pts_limit: pts_limit,
-          pts_total_limit: pts_total_limit,
-          date: date,
-          qts: qts,
-          qts_limit: qts_limit
-        )
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'pts is required' if pts.nil?
-        raise ArgumentError, 'date is required' if date.nil?
-        raise ArgumentError, 'qts is required' if qts.nil?
-
-        query = Type::RPC::Updates::GetDifference.build(
-          pts: pts,
-          pts_limit: pts_limit,
-          pts_total_limit: pts_total_limit,
-          date: date,
-          qts: qts,
-          qts_limit: qts_limit
-        )
-
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Updates::Difference.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_updates_state.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/updates/get_state'
-require_relative '../type/rpc/updates/state'
-
-module MTProto
-  module RPC
-    class GetUpdatesState
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Updates::GetState.build
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Updates::GetState.build
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Updates::State.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_users.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/users/get_users'
-require_relative '../type/rpc/users/users'
-
-module MTProto
-  module RPC
-    class GetUsers
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Users::GetUsers.build
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Users::GetUsers.build
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Users::Users.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/ping.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/ping'
-require_relative '../type/rpc/pong'
-
-module MTProto
-  module RPC
-    class Ping
-      def initialize(client)
-        @client = client
-      end
-
-      def call(ping_id = nil)
-        ping_id ||= rand(2**63)
-        body = Type::RPC::Ping.build(ping_id)
-
-        @client.rpc.call(body)
-      end
-
-      def call_sync(ping_id = nil)
-        ping_id ||= rand(2**63)
-        body = Type::RPC::Ping.build(ping_id)
-
-        response_body = @client.rpc.call_sync(body)
-        pong = Type::RPC::Pong.parse(response_body)
-
-        raise PingMismatchError unless pong[:ping_id] == ping_id
-
-        true
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/send_code.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/auth/send_code'
-require_relative '../type/rpc/auth/sent_code'
-
-module MTProto
-  module RPC
-    class SendCode
-      def initialize(client)
-        @client = client
-      end
-
-      def call(phone_number, code_settings: {})
-        query = build_query(phone_number, code_settings)
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(phone_number, code_settings: {})
-        query = build_query(phone_number, code_settings)
-
-        response = @client.rpc.call_sync(query)
-
-        Type::RPC::Auth::SentCode.parse(response)
-      end
-
-      private
-
-      def build_query(phone_number, code_settings)
-        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
-
-        Type::RPC::Auth::SendCode.build(
-          phone_number: phone_number,
-          api_id: @client.api_id,
-          api_hash: @client.api_hash,
-          code_settings: code_settings
-        )
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/send_message.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/messages/send_message'
-require_relative '../type/rpc/messages/updates'
-
-module MTProto
-  module RPC
-    class SendMessage
-      def initialize(client)
-        @client = client
-      end
-
-      def call(user_id:, access_hash:, message:, random_id: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'user_id is required' if user_id.nil?
-        raise ArgumentError, 'access_hash is required' if access_hash.nil?
-        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
-
-        query = Type::RPC::Messages::SendMessage.build(
-          user_id: user_id,
-          access_hash: access_hash,
-          message: message,
-          random_id: random_id
-        )
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(user_id:, access_hash:, message:, random_id: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'user_id is required' if user_id.nil?
-        raise ArgumentError, 'access_hash is required' if access_hash.nil?
-        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
-
-        query = Type::RPC::Messages::SendMessage.build(
-          user_id: user_id,
-          access_hash: access_hash,
-          message: message,
-          random_id: random_id
-        )
-
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Messages::Updates.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/sign_in.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/auth/sign_in'
-require_relative '../type/rpc/auth/authorization'
-
-module MTProto
-  module RPC
-    class SignIn
-      def initialize(client)
-        @client = client
-      end
-
-      def call(phone_number:, phone_code_hash:, phone_code:)
-        query = build_query(phone_number, phone_code_hash, phone_code)
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(phone_number:, phone_code_hash:, phone_code:)
-        query = build_query(phone_number, phone_code_hash, phone_code)
-
-        response = @client.rpc.call_sync(query)
-
-        result = Type::RPC::Auth::Authorization.parse(response)
-
-        if result[:authorization] && result[:user_id]
-          @client.update_user(user_id: result[:user_id], access_hash: result[:access_hash])
-        end
-
-        result
-      end
-
-      private
-
-      def build_query(phone_number, phone_code_hash, phone_code)
-        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
-        raise ArgumentError, 'phone_code_hash is required' if phone_code_hash.nil? || phone_code_hash.empty?
-        raise ArgumentError, 'phone_code is required' if phone_code.nil? || phone_code.empty?
-
-        Type::RPC::Auth::SignIn.build(
-          phone_number: phone_number,
-          phone_code_hash: phone_code_hash,
-          phone_code: phone_code
-        )
-      end
-    end
-  end
-end