mtproto 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf09099f0d758aef9c9b4f31c1aa0d4f35fa0bcd25f5fd405dcededb4e72bd03
-  data.tar.gz: f79bed71d80f9856024a05c2f6abc244bf6dcc41456611e10410b7cffe315c76
+  metadata.gz: f989bd9b9704f0fbb46d0c538a2f0dfea8e1c9a387830e875ffecc44b0ad872a
+  data.tar.gz: acd4865006b5a95364fd5cfaf4db71366137571faeedd1623edf20bae0e3bf9e
 SHA512:
-  metadata.gz: 9749b7de5172cad33106451be16e1c232fcbfaa24ecc97a5979d973ac9ba80617f7e4bee318a8a3f89fdf2bbf9f8473d821885640c46f86907a49ddb2d8ff724
-  data.tar.gz: 6aa58a6d2d873becd74cd037f39b237f5bc092a9cf541453000a85f3ee44406c93356fcf3818256f5c2a4f33b9e58a6d239b366d847b59a053fe05ce3a38279f
+  metadata.gz: 20d07a1e57c051d9ca1a3617191e7222b7bd2a6674546473c00130a5cec94ef6dae02c0ce2f0c1cc2df5fd924aadeea3d0405a39f931ec345ba87575bb0183ad
+  data.tar.gz: 91f8f836e61180a4fb41b1ca9a56807449e809acf794b7b01fbf7c3bd34ae7ebb4d18c704fc1c53045777e49bc73fb0f604fc2b20c59f54c41afe5a12ff689ff

data/lib/mtproto/tl/objects/updates_difference.rb

@@ -1,20 +1,27 @@
 # frozen_string_literal: true
 
+require_relative '../schema'
+
 module MTProto
   module TL
     class UpdatesDifference
-      attr_reader :type, :date, :seq, :new_messages, :users, :pts, :state
+      attr_reader :type, :date, :seq, :new_messages, :pts, :state
+
+      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
 
-      def initialize(type:, date: nil, seq: nil, new_messages: [], users: [], pts: nil, state: nil)
+      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil)
         @type = type
         @date = date
         @seq = seq
         @new_messages = new_messages
-        @users = users
         @pts = pts
         @state = state
       end
 
+      def self.schema
+        @schema ||= Schema.new(SCHEMA_PATH)
+      end
+
       def self.parse(data)
         constructor = data[0, 4].unpack1('L<')
 
@@ -31,6 +38,10 @@ module MTProto
         end
       end
 
+      MESSAGE_CONSTRUCTOR = Constructors::MESSAGE
+      MESSAGE_SERVICE = 0x7a800e0a
+      MESSAGE_EMPTY = 0x90a6ca84
+
       class << self
         private
 
@@ -42,19 +53,21 @@ module MTProto
           )
         end
 
+        # updates.difference: new_messages new_encrypted_messages other_updates chats users state
         def parse_difference(data, constructor)
           offset = 4
 
           messages, offset = parse_messages_vector(data, offset)
-          offset = skip_vector(data, offset) # encrypted_messages
-          offset = skip_vector(data, offset) # other_updates
-          offset = skip_vector(data, offset) # chats
-          users, = parse_users_vector(data, offset)
+          offset = schema.skip_vector(data, offset) # new_encrypted_messages
+          offset = schema.skip_vector(data, offset) # other_updates
+          offset = schema.skip_vector(data, offset) # chats
+          offset = schema.skip_vector(data, offset) # users
+          state = UpdatesState.parse(data[offset..])
 
           new(
             type: constructor == Constructors::UPDATES_DIFFERENCE ? :difference : :slice,
             new_messages: messages,
-            users: users
+            state: state
           )
         end
 
@@ -65,71 +78,39 @@ module MTProto
 
           messages = []
           count.times do
-            msg, offset = parse_message(data, offset)
+            constructor = data[offset, 4].unpack1('L<')
+            msg = extract_message(data, offset, constructor)
             messages << msg if msg
+            offset = schema.skip(data, offset)
           end
           [messages, offset]
         end
 
-        def parse_message(data, offset)
-          msg_constructor = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          return [nil, offset] unless msg_constructor == Constructors::MESSAGE
+        def extract_message(data, offset, constructor)
+          return unless constructor == MESSAGE_CONSTRUCTOR
 
+          offset += 4 # constructor
           flags = data[offset, 4].unpack1('L<')
           offset += 4
-          id = data[offset, 4].unpack1('L<')
+          flags2 = data[offset, 4].unpack1('L<')
           offset += 4
-          offset += 12 if flags.anybits?(1 << 8) # from_id
-          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
-          offset += 12 # peer_id
-          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
-          date = data[offset, 4].unpack1('L<')
+          id = data[offset, 4].unpack1('l<')
           offset += 4
-          message_text, offset = read_tl_string(data, offset)
 
-          [{ id: id, date: date, message: message_text, flags: flags }, offset]
-        rescue StandardError
-          [nil, offset]
-        end
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          offset = schema.skip(data, offset) # peer_id (Peer, always present)
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 2) # fwd_from
+          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
+          offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
 
-        def parse_users_vector(data, offset)
-          offset += 4 # vector constructor
-          count = data[offset, 4].unpack1('L<')
+          date = data[offset, 4].unpack1('L<')
           offset += 4
+          message_text, = read_tl_string(data, offset)
 
-          users = []
-          count.times do
-            user_constructor = data[offset, 4].unpack1('L<')
-            offset += 4
-            next unless user_constructor == Constructors::USER
-
-            flags = data[offset, 4].unpack1('L<')
-            offset += 4
-            offset += 4 # flags2
-            user_id = data[offset, 8].unpack1('Q<')
-            offset += 8
-
-            access_hash = nil
-            if flags.anybits?(1 << 0)
-              access_hash = data[offset, 8].unpack1('Q<')
-              offset += 8
-            end
-
-            users << { id: user_id, access_hash: access_hash }
-          rescue StandardError
-            break
-          end
-          [users, offset]
-        end
-
-        def skip_vector(data, offset)
-          offset += 4 # vector constructor
-          count = data[offset, 4].unpack1('L<')
-          offset += 4
-          count.times { offset += 4 }
-          offset
+          { id: id, date: date, message: message_text }
         end
 
         def read_tl_string(data, offset)
@@ -144,7 +125,7 @@ module MTProto
             total = 1 + len
           end
           padding = (4 - (total % 4)) % 4
-          [data[offset + (total - len), len], offset + total + padding]
+          [data[offset + (total - len), len].force_encoding('UTF-8'), offset + total + padding]
         end
       end
     end

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/lib/mtproto.rb

@@ -33,7 +33,6 @@ require_relative 'mtproto/auth_key_generator'
 require_relative 'mtproto/session'
 require_relative 'mtproto/encrypted_message'
 require_relative 'mtproto/client'
-require_relative 'mtproto/updates_poller'
 
 module MTProto
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Artem Levenkov
@@ -137,7 +137,6 @@ files:
 - lib/mtproto/transport/errors.rb
 - lib/mtproto/transport/packet.rb
 - lib/mtproto/transport/tcp_connection.rb
-- lib/mtproto/updates_poller.rb
 - lib/mtproto/version.rb
 - scripts/generate_constructors.rb
 - tmp/.keep

data/lib/mtproto/updates_poller.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  class UpdatesPoller
-    attr_reader :state, :running
-
-    def initialize(client, poll_interval: 1.0)
-      @client = client
-      @poll_interval = poll_interval
-      @state = nil
-      @running = false
-      @on_message_callbacks = []
-      @on_update_callbacks = []
-      @users_cache = {}
-    end
-
-    def on_message(&block)
-      @on_message_callbacks << block
-    end
-
-    def on_update(&block)
-      @on_update_callbacks << block
-    end
-
-    def start
-      raise 'Already running' if @running
-      raise 'Auth key not set' unless @client.auth_key?
-
-      @running = true
-
-      @state = call_with_retry { @client.api.get_updates_state }
-
-      poll_loop
-    end
-
-    def stop
-      @running = false
-    end
-
-    private
-
-    def poll_loop
-      while @running
-        begin
-          difference = call_with_retry do
-            @client.api.get_updates_difference(
-              pts: @state.pts,
-              date: @state.date,
-              qts: @state.qts
-            )
-          end
-
-          process_difference(difference)
-
-          if difference.state
-            @state = difference.state
-          elsif difference.type == :too_long
-            @state = call_with_retry { @client.api.get_updates_state }
-          elsif difference.date
-            @state.date = difference.date
-          end
-
-          sleep @poll_interval
-        rescue MTProto::RpcError => e
-          warn "RPC Error during polling: #{e.message}"
-          sleep @poll_interval
-        rescue StandardError => e
-          warn "Error during polling: #{e.class} - #{e.message}"
-          warn e.backtrace.first(5).join("\n")
-          sleep @poll_interval
-        end
-      end
-    end
-
-    def call_with_retry(max_retries: 5)
-      retries = 0
-      begin
-        yield
-      rescue MTProto::UnexpectedConstructorError, RuntimeError
-        retries += 1
-        retry if retries < max_retries
-        raise
-      end
-    end
-
-    def process_difference(difference)
-      case difference.type
-      when :empty
-        nil
-      when :difference, :slice, :short_message
-        difference.users&.each do |user|
-          @users_cache[user[:id]] = user[:access_hash] if user[:access_hash]
-        end
-
-        if difference.new_messages && !difference.new_messages.empty?
-          difference.new_messages.each do |message|
-            process_message(message)
-          end
-        end
-
-        @on_update_callbacks.each { |callback| callback.call(difference) }
-      when :too_long
-        puts "Update gap too long (pts=#{difference.pts}), refreshing state..."
-      end
-    end
-
-    def process_message(message)
-      return unless message
-
-      message[:access_hash] = @users_cache[message[:user_id]] if message[:user_id] && @users_cache[message[:user_id]]
-
-      @on_message_callbacks.each { |callback| callback.call(message) }
-    end
-  end
-end