Che cosa succede se un'applicazione chiama più di 10 URL asincrona Fetch su Google App Engine?

Question

Lettura del Google App Engine documentazione su URL asincrono Fetch :

  

L'applicazione può avere fino a 10 simultanea   URL asincrono Fetch chiamate

Che cosa succede se le chiamate un'applicazione più di 10 asincroni recuperano alla volta?
Fa Google App Engine sollevare un'eccezione o semplicemente in coda il rimangono chiamate in attesa di servire loro?

Answer 1

Umm, Swizzec non è corretto. Abbastanza facile da prova:

rpc = []
for i in range(1,20):
    rpc.append(urlfetch.createrpc())
    urlfetch.make_fetch_call(rpc[-1],"http://stackoverflow.com/questions/3639855/what-happens-if-i-call-more-than-10-asynchronous-url-fetch")

for r in rpc:
    response = r.get_result().status_code

Questa non restituisce alcuna eccezione. In realtà, questo funziona bene! Si noti che i risultati possono variare per le applicazioni non fatturabili.

Quello che sta riportando Swizec è un problema diverso, relative al numero massimo di connessioni simultanee nella vostra applicazione. Per le applicazioni fatturabili non v'è alcun limite pratico qui btw, solo scale out (fatte salve le 1000ms regola).

GAE non ha alcun modo di sapere che il vostro gestore di richieste emetterà un blocco URL recuperare, in modo che il collegamento 500 che sta vedendo, non sono legati a ciò che la sua applicazione è effettivamente facendo (che è una semplificazione eccessiva btw, se il tempo medio di richiesta di risposta è > 1000 ms tua likelyhood degli aumenti di 500).

Answer 2

Questa è una vecchia questione, ma credo che la risposta accettata è errata o non aggiornate e può confondere la gente. E 'stato un paio di mesi che ho effettivamente provato questo, ma nella mia esperienza Swizec è del tutto giusto che GAE non coda, ma piuttosto fallirà URL recupera più asincroni che superano il limite di circa 10 quelli simultanei per ogni richiesta.

https://developers.google.com/appengine/docs/python/urlfetch/# Python_Making_requests e https://groups.google.com/forum/#!topic/ google-appengine / EoYTmnDvg8U per una descrizione del limite.

David Underhill ha messo a punto un URL Fetch Manager per Python , che accoda recuperi URL asincroni che superano il limite di codice di applicazione.

Ho implementato qualcosa di simile per Java, che sincrono blocchi (a causa della mancanza di una funzione di callback o ListenableFutures) ulteriori richieste:

/**
 * A URLFetchService wrapper that ensures that only 10 simultaneous asynchronous fetch requests are scheduled. If the
 * limit is reached, the fetchAsync operations will block until another request completes.
 */
public class BlockingURLFetchService implements URLFetchService {
    private final static int MAX_SIMULTANEOUS_ASYNC_REQUESTS = 10;

    private final URLFetchService urlFetchService = URLFetchServiceFactory.getURLFetchService();
    private final Queue<Future<HTTPResponse>> activeFetches = new LinkedList<>();

    @Override
    public HTTPResponse fetch(URL url) throws IOException {
        return urlFetchService.fetch(url);
    }

    @Override
    public HTTPResponse fetch(HTTPRequest request) throws IOException {
        return urlFetchService.fetch(request);
    }

    @Override
    public Future<HTTPResponse> fetchAsync(URL url) {
        block();

        Future<HTTPResponse> future = urlFetchService.fetchAsync(url);
        activeFetches.add(future);
        return future;
    }

    @Override
    public Future<HTTPResponse> fetchAsync(HTTPRequest request) {
        block();

        Future<HTTPResponse> future = urlFetchService.fetchAsync(request);
        activeFetches.add(future);
        return future;
    }

    private void block() {
        while (activeFetches.size() >= MAX_SIMULTANEOUS_ASYNC_REQUESTS) {
            // Max. simultaneous async requests reached; wait for one to complete
            Iterator<Future<HTTPResponse>> it = activeFetches.iterator();
            while (it.hasNext()) {
                if (it.next().isDone()) {
                    it.remove();
                    break;
                }
            }
        }
    }
}

Answer 3

500 errori iniziano accada. In silenzio.

Hai solo scoprire queste quando si guarda il registro in tutte le richieste (non si ottiene elencato come errori). Dice semplicemente "La richiesta è stata interrotta perché è arrivata al limite richieste simultanee".

Così, quando si sta facendo un sacco di chiamate asincrone, assicurarsi che è possibile gestire alcuni di loro spazzing fuori.

Answer 4

vedere se questo risponde alla tua domanda:

http://groups.google.com/ gruppo / google-appengine / browse_thread / thread / 1286139a70ef83c5? FWC = 1