Ich stecke fest, wenn ich einige Java-Code-Teile schreibe, die versuchen, eine Zieldatei von einem Remote-Host herunterzuladen, indem ich sie entferne. Ich erwarte, dass einige Chunks, die sich auf einen Multithread-Prozess stützen, Remotedateien herunterladen.

Aufzeichnung nach Debug-Trace läuft alles einwandfrei:

Task 2 --> REQUEST PROPERTIES =  {Range=[bytes=59124782-88687172]}
Task 3 --> REQUEST PROPERTIES =  {Range=[bytes=88687173-118249563]}
Task 0 --> REQUEST PROPERTIES =  {Range=[bytes=0-29562390]}
Task 1 --> REQUEST PROPERTIES =  {Range=[bytes=29562391-59124781]}
Task 2 --> RETURN_CODE = 206 ==> OK :-) !
Task 2 --> Start Byte = 59124782 / End Byte = 88687172 --> Total bytes = 29562391
Task 0 --> RETURN_CODE = 206 ==> OK :-) !
Task 0 --> Start Byte = 0 / End Byte = 29562390 --> Total bytes = 29562391
Task 3 --> RETURN_CODE = 206 ==> OK :-) !
Task 3 --> Start Byte = 88687173 / End Byte = 118249563 --> Total bytes = 29562391
Task 1 --> RETURN_CODE = 206 ==> OK :-) !
Task 1 --> Start Byte = 29562391 / End Byte = 59124781 --> Total bytes = 29562391

Aufzeichnung nach Debug-Trace läuft alles NICHT gut:

Task 0 --> REQUEST PROPERTIES =  {Range=[bytes=0-15308169]}
Task 3 --> REQUEST PROPERTIES =  {Range=[bytes=45924510-61232679]}
Task 1 --> REQUEST PROPERTIES =  {Range=[bytes=15308170-30616339]}
Task 2 --> REQUEST PROPERTIES =  {Range=[bytes=30616340-45924509]}
Task 0 --> RETURN_CODE = 206 ==> OK :-) !
Task 0 --> Start Byte = 0 / End Byte = 15308169 --> Total bytes = 15308170
Task 3 --> RETURN_CODE = 200 ==> NOK :-( !
Task 2 --> RETURN_CODE = 200 ==> NOK :-( !
Task 1 --> RETURN_CODE = 200 ==> NOK :-( !

Trick ist zwischen 2 Läufen gleich, der Remote-Host ist gleich ... nur die Zieldatei ist nicht gleich (die zweite ist halb so klein wie die erste und beide sind ZIP-Dateien). Als Anforderung für einen definierten Bereich erwarte ich für jede Aufgabe 206 einen Rückkehrcode, der bestätigt, dass Teildaten empfangen werden. Aber unter Berufung auf die zweite Ablaufverfolgung erhalte ich für 3 den letzten Task 200-Code, was bedeutet, dass die Serverantwort in Ordnung ist, aber die vollständige Datei sendet :-( ....

Welcher König der schwarzen Magie kann zu solchen führen ????. Ein bisschen googeln Ich habe festgestellt, dass einige http-Server einen Bereich-Anfrage-Zusammenführungsprozess einleiten können ... kann so etwas hier passieren?

Wenn mehrere Bereiche angefordert werden, KANN ein Server alle Bereiche zusammenführen, die sich überlappen oder die durch eine Lücke getrennt sind, die kleiner als der Aufwand für das Senden mehrerer Teile ist, unabhängig von der Reihenfolge, in der die entsprechende Byte-Bereichsspezifikation angezeigt wurde im empfangenen Range-Header-Feld. Da der typische Overhead zwischen Teilen einer Nutzlast mit mehreren Teilen / Bytes etwa 80 Bytes beträgt, kann es abhängig vom Medientyp der ausgewählten Darstellung und der Länge der ausgewählten Grenzparameter weniger effizient sein, viele kleine, nicht zusammenhängende Teile zu übertragen, als das gesamte ausgewählte zu übertragen Darstellung

Nur zur Info hier ist mein Stück Java-Code:

HttpURLConnection urlConn = null;
try {
    urlConn = task.openConnection(task.getSourceFileUrl());
    urlConn.setRequestMethod("GET");
    urlConn.setRequestProperty("Range", "bytes=" + currentByte + "-" + endByte + "");

    System.out.println(String.format("Task %s --> REQUEST PROPERTIES =  %s", id, urlConn.getRequestProperties().toString()));

    if (urlConn.getResponseCode() != HttpURLConnection.HTTP_PARTIAL) {
        System.out.println(String.format("Task %s --> RETURN_CODE = %s ==> NOK :-( !", id, urlConn.getResponseCode()));
        return;
    } else {
        System.out.println(String.format("Task %s --> RETURN_CODE = %s ==> OK :-) !", id, urlConn.getResponseCode()));
    }

    System.out.println(String.format("Task %s --> Start Byte = %s / End Byte = %s --> Total bytes = %s", id, currentByte, endByte, urlConn.getContentLengthLong()));

Thks für Hilfe !!!!!