Co może powodować, że połączenie z APNS może się sporadycznie rozłączać?

Question

Mam skrypt ruby, który otwiera połączenie z serwerem Push firmy Apple i wysyła wszystkie oczekujące powiadomienia. Nie widzę żadnego powodu, ale dostaję zepsute błędy, gdy Apple rozłączy mój skrypt. Napisałem scenariusz, aby się do tego dostosować, ale wolałbym po prostu dowiedzieć się, dlaczego tak się dzieje, więc mogę tego uniknąć.

Nie powoduje on ciągłego rozłączania się z konkretnym powiadomieniem. Nie rozłącza się przy określonym rozmiarze transferu bajtów. Wszystko wydaje się być sporadyczne. Czy istnieją pewne ograniczenia dotyczące przesyłania danych lub liczby ładunków, które można wysłać na jednym połączeniu? Widząc rozwiązania ludzi, które utrzymują jedno połączenie otwarte przez cały czas, zakładam, że to nie problem. Widziałem spadek połączenia po 3 powiadomieniach i widziałem spadek po 14 powiadomieniach. Nigdy nie widziałem, aby minęło 14.

Czy ktoś jeszcze doświadczył tego typu problemów? Jak można to załatwić?

Answer 1

Problem został spowodowany przez wysłanie na serwer APNS nieprawidłowego tokenu urządzenia. W tym konkretnym przypadku był to żeton rozwoju. Kiedy nieprawidłowy token urządzenia jest wysyłany do APNS, odłącza gniazdo. Może to powodować pewne bóle głowy, i został rozwiązany przez Apple jako coś, co zamierzają rozwiązać w przyszłych aktualizacjach.

Answer 2

miałem ten sam problem na trochę i zrobił dwie rzeczy, aby je zająć się:

1. umieścić niektóre logiki automatycznego ponownego połączenia w miejscu: Staram się zachować moje połączenie tak długo, jak to możliwe, ale Apple będzie odłączyć od czasu do czasu. Przygotuj się na to.
2. Przejście do ulepszonego interfejsu: użycie prostego interfejsu (który jest wykorzystywany przez klej APNS i wiele innych) spowoduje odłączenie bez żadnej informacji zwrotnej. Jeśli przełączysz się na enhanced format, otrzymasz liczbę całkowitą za każdym razem, gdy coś się stanie. Złe tokeny spowodują zwrócenie wartości 8 i używam jej do usunięcia urządzenia z mojej bazy danych.

Oto mój aktualny kod połączenie, używając EventMachine:

module Apns 

    module SocketHandler 
    def initialize(wrapper) 
     @wrapper = wrapper 
    end 

    def post_init 
     start_tls(:cert_chain_file => @wrapper.pem_path, 
       :private_key_file => @wrapper.rsa_path, 
       :verify_peer => false) 
    end 

    def receive_data(data) 
     @wrapper.read_data!(data) 
    end 

    def unbind 
     @wrapper.connection_closed! 
    end 

    def write(data) 
     begin 
     send_data(data) 
     rescue => exc 
     @wrapper.connection_error!(exc) 
     end 
    end 

    def close! 
     close_connection 
    end 
    end 

    class Connection 
    attr_reader :pem_path, :rsa_path 

    def initialize(host, port, credentials_path, monitoring, read_data_handler) 
     setup_credentials(credentials_path) 
     @monitoring = monitoring 
     @host = host 
     @port = port 
     @read_data_handler = read_data_handler 
     open_connection! 
    end 

    def write(data) 
     @connection.write(data) 
    end 

    def open? 
     @status == :open 
    end 

    def connection_closed! 
     @status = :closed 
    end 

    def connection_error!(exception) 
     @monitoring.inform_exception!(exception, self) 
     @status = :error 
    end 

    def close! 
     @connection.close! 
    end 

    def read_data!(data) 
     @read_data_handler.call(data) 
    end 

    private 
    def setup_credentials(credentials_path) 
     @pem_path = "#{credentials_path}.pem" 
     @rsa_path = "#{credentials_path}.rsa" 
     raise ArgumentError.new("#{credentials_path}.pem and #{credentials_path}.rsa must exist!") unless (File.exists?(@pem_path) and File.exists?(@rsa_path)) 
    end 

    def open_connection! 
     @connection = EventMachine.connect(@host, @port, SocketHandler, self) 
     @status = :open 
    end 
    end 
end 

końcowy koniec

Oddziela on pisze i czyta w związku z tym, korzystając z pola ID w powiadomieniu skorelowanych powiadomień wysyłanych z otrzymywanym sprzężeniem zwrotnym.