Finde Fehler bei Download in Segmenten Code nicht

  • VB.NET

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von Kangaroo.

    Finde Fehler bei Download in Segmenten Code nicht

    Hi Community,

    Ich hab hier einen Code geschrieben, der mir das Downloaden von Dateien in Segmenten ermöglicht.
    Das Problem: beim erstellen des 2. Segments passiert gar nichts.
    Ich keinen Plan woran das liegen kann. Das Programm läuft ja. Es wartet nur auf eine Antwort vom Server, die es anscheinend nicht bekommt.
    Hoffe ihr könnt mir helfen und danke schon mal im vorraus.

    P.S: Wenn der Code dann endlich läuft verpack ich den Code in eine Klasse, die den Code asynchron aufruft und stelle es hier ins Forum.

    Hier mein Code:

    VB.NET-Quellcode

    1. Imports System.Net
    2. Imports System.IO
    3. Module SegmentDownlaod
    5. Const BufferSize As Integer = 65536
    7. Sub Main(ByVal args() As String)
    8. If args.Length <> 3 Then
    9. Console.WriteLine("Ungültige Anzahl der Argumente!")
    10. Console.ReadLine()
    11. Exit Sub
    12. End If
    14. 'Einstellungen speichern
    15. Dim DownloadPath As String = args(0)
    16. Dim SavePath As String = args(1)
    17. Dim SegmentCount As Integer = CInt(args(2))
    19. 'Einstellungen anzeigen
    20. Console.WriteLine("Speichere " & DownloadPath & " unter " & SavePath & " in " & SegmentCount & " Segmenten.")
    21. Console.WriteLine()
    23. 'Downloadgröße abrufen und anzeigen
    24. Dim DownloadLength As Long = GetDownloadLength(DownloadPath)
    25. Console.WriteLine("Downloadgröße: " & DownloadLength & "Bytes")
    26. Console.WriteLine()
    28. 'Liste zum speichern der Segmente
    29. Dim Segment(SegmentCount - 1) As BinaryReader
    30. Dim SegmentLength(SegmentCount - 1) As Long
    31. Dim SegmenthRecieve(SegmentCount - 1) As Long
    32. Dim SegmentCompleted(SegmentCount - 1) As Boolean
    33. Dim CompletedSegments As Integer = 0
    35. 'Segmente erstellen
    36. For i% = 1 To SegmentCount
    37. 'Segmentschnitt bestimmen
    38. Dim StartS As Integer = CInt((i - 1) * (DownloadLength / SegmentCount))
    39. Dim EndS As Integer = CInt(i * (DownloadLength / SegmentCount))
    40. If i < SegmentCount Then EndS -= 1
    41. Console.WriteLine("Segment " & i & " von " & StartS & " bis " & EndS)
    45. 'Segment erstellen
    47. 'Download anfordern
    48. Dim Request As HttpWebRequest = CType(HttpWebRequest.Create(DownloadPath), HttpWebRequest)
    49. Request.AddRange(StartS, EndS)
    50. Dim Response As HttpWebResponse = CType(Request.GetResponse(), HttpWebResponse)
    51. 'Download in Liste ablegen
    52. Segment(i - 1) = New BinaryReader(Response.GetResponseStream())
    54. Console.WriteLine("Segment " & i & " ertsellt!")
    55. Console.WriteLine()
    56. Next
    58. 'Datei erstellen
    59. Dim FileStream As New FileStream(SavePath, FileMode.Create)
    60. FileStream.SetLength(DownloadLength)
    61. Dim Writer As New BinaryWriter(FileStream)
    63. 'Segmente zusammenführen und speichern
    64. Do
    65. 'Jedes Segment einzeln bearbeiten
    66. For i% = 0 To SegmentCount - 1
    67. 'Überprüfen, ob segment fertig
    68. If Not SegmentCompleted(i) Then
    70. 'Position festlegen
    71. Dim Length As Long
    72. For n% = 0 To i - 1
    73. Length += SegmentLength(n)
    74. Next
    75. Length += SegmenthRecieve(i)
    76. 'positionieren
    77. Writer.Seek(CInt(Length), SeekOrigin.Begin)
    79. 'Segment in Datei schreiben
    80. Dim Count As Integer = 0
    81. Dim Buffer(BufferSize - 1) As Byte
    82. Count = Segment(i).Read(Buffer, 0, BufferSize)
    83. Writer.Write(Buffer, 0, Count)
    85. 'Informationen aktualisieren und ausgeben
    86. SegmenthRecieve(i) += Count
    88. Console.WriteLine("Segment {0}: {1]Bytes von {2}Bytes : {3}%", i, SegmenthRecieve(i), SegmentLength(i), SegmenthRecieve(i) / SegmentLength(i))
    90. 'Überprüfen, ob Segment fertig ist
    91. If SegmenthRecieve(i) = SegmentLength(i) Then
    92. SegmentCompleted(i) = True
    93. CompletedSegments+= 1
    94. Console.WriteLine("Segment " & i & " fertig!")
    95. End If
    96. End If
    97. Next
    98. Loop Until CompletedSegments = SegmentsCount
    100. Console.WriteLine("Download fertig!")
    102. Console.ReadLine()
    103. End Sub
    105. Private Function GetDownloadLength(ByVal uri As String) As Long
    106. Dim Request As HttpWebRequest = CType(HttpWebRequest.Create(uri), HttpWebRequest)
    107. Request.Method = "HEAD"
    108. Return Request.GetResponse.ContentLength
    109. End Function
    111. End Module

    Auf die Schnelle konnte ich dein Problem jetzt nicht feststellen. Bist du schon einmal mit dem Debugger Schritt für Schritt durchgegangen?
    Aber mir sind ein paar andere Dinge aufgefallen: Die Streams sollten immer irgendwo wieder geschlossen werden (Close-Methode der WebResponse aufrufen). Beim Downloaden eines zweiten Segments muss irgendwo im HttpHeader angegeben werden, dass du die Daten nicht von Beginn an, sondern ab der Position des Segments anfordern willst.

    Und außerdem, normalerweise führt man Downloads an einem Stück durch - was bezweckst du mit den Segmenten, die ja alles nur verkomplizieren? Mehr Geschwindigkeit wirst du damit wohl eher nicht herausbekommen.

    Ja, ich den Code Schritt für Schritt durchgegangen und konnte den Fehler nicht finden.
    Das mit den Streams stimmt, das sollte aber nur ein Test sein. Werds noch ausbessern.
    Der Start- und Endpunkt des Segments werden ja immer durch Request.Addange() festgelegt.

    Und außerdem, das zerlegen des Downloads in Segmente beschert mir einen unglaublichen Geschwindigkeitsschub.
    Manchmal sogar bis zu 100%!
    Falls du es mir nicht galubst: en.wikipedia.org/wiki/Download_manager

    The reason for doing so is to circumvent server side limitations of bandwidth per connection.

    Wenn dieser Fall eintritt hast du recht, dann können mehrere Verbindungen tatsächlich einen Geschwindigkeitsvorteil bringen. Da ich nur DSL 6000 habe und die wenigsten Server (außer Billig-On-Click-Hoster) eine Begrenzung einbauen, die darunter fällt, hab ich garnicht daran gedacht. Natürlich begrenzen auch einige Server die Anzahl der Verbindungen pro IP-Adresse.

    Der Start- und Endpunkt des Segments werden ja immer durch Request.Addange() festgelegt.

    Habe ich übersehen. Und ich habe auch nicht gewusst, dass das so einfach geht mit dem .Net-Framework, dachte man muss selber den Header entsprechend anpassen. Das macht das Framework für dich dann intern, wenn du diese Methode aufrufst. Allerdings kann es sein, dass nicht alle Server diesen Header auch beachten/unterstützen. Vielleicht liegt auch hier der Fehler.

    Das Programm bleibt also beim Aufruf der Methode getResponse() "hängen"?

    Infinity schrieb:

    Wenn dieser Fall eintritt hast du recht, dann können mehrere Verbindungen tatsächlich einen Geschwindigkeitsvorteil bringen.
    Das können sie auf jeden Fall, die erwähnten Downloadmanger arbeiten nach dem gleichen Prinzip. Allerdings nur wenn die Segmente in parallelen Verbindungen heruntergeladen werden.

    Me.Net schrieb:

    Und außerdem, das zerlegen des Downloads in Segmente beschert mir einen unglaublichen Geschwindigkeitsschub
    Das glaube ich so nicht. Du müsstest dazu die Async-Methoden des HttpWebRequest verwenden um die Segmente parallel zu laden. Momentan wartest Du in der Schleife bis der Response des einen Segmentes zurück kommt (=blocking).

    Infinity schrieb:

    Natürlich begrenzen auch einige Server die Anzahl der Verbindungen pro IP-Adresse
    Das tun die meisten, gerade um die Downloadmanager auszubremsen. Bei Apache-Servern ist die Regel nur 2-3 Verbindungen von der gleichen IP-Adresse zuzulassen.

    Infinity schrieb:

    Die Streams sollten immer irgendwo wieder geschlossen werden (Close-Methode der WebResponse aufrufen). Beim Downloaden eines zweiten Segments muss irgendwo im HttpHeader angegeben werden, dass du die Daten nicht von Beginn an, sondern ab der Position des Segments anfordern willst
    Beides richtig. Für nicht verwaltete Ressourcen wie Streams verwendet man das Using-Statement. Wie in dem Beispielcode in diesem Beitrag Post #4

    Es ist einer der ersten Codes wo ich sehe dass jemand den 'HEAD' Request benutzt, das finde ich sehr gut. Allerdings geben nicht alle/nur einge Server die Contentlength einier Datei zurück, oft ist sie -1. Genauso steht es mit dem Ansprechen von bestimmten Segmenten: auch das wird definitv nicht von allen Servern unterstützt.

    Gruss

    @Infinty: Ja, es hängt bei GetResponse(), aber erst, wenn die Schleife den Befehl zum zweiten mal erreicht.

    @Kangoroo: Das mit den Geschwindigkeitsschub war falsch formuliert von mir. Ich meinte die Downloadgeschwindigkeit, nicht die Geschwindigkeit des Programms.
    Das einige Server die Verbindungen pro IP-Adresse begrenzen wusste ich, ich habe aber die Datei, die ich zum testen downloaden wollte schon vorher mit DownThemAll heruntergeladen. Und das Programm baute 10 Verbindungen auf.
    Wie bereits erwähnt ist der Code nur zum Testen des Grundsystems gedacht. Das mit dem Streams habe ich einfach übersehen. Der Code beinhalet auch keine Fehlerbehandlung.

    Langsam vermute ich, dass ich einen Bug im .Net-Framework aufgedeckt habe....

    Me.Net schrieb:

    Langsam vermute ich, dass ich einen Bug im .Net-Framework aufgedeckt habe....
    Das vermuten wir am Anfang alle, bis wir dann merken dass der Fehler direkt vor dem Bildschirm sitzt ;)

    Ich habe Deinen Code mal überflogen, ohne ihn testen zu wollen: sei mir nicht böse, aber der ist schon ziemlich grausam :huh:

    Aber um auf Dein aktuelles Problem zu kommen: ich vermute mal er hängt am ServicePoint Limit. Gib mal versuchsweise gib mal nach Zeile 48 folgendes ein:

    VB.NET-Quellcode

    1. request.servicePoint.connectionLimit = 10

    aber der ist schon ziemlich grausam

    Um den Code zu verbessern, könntest du z. B. damit anfangen, nur einen Ausgabestream zu verwenden, anstatt mehrere, die dann hinterher wieder zusammengefügt werden. Du kannst ja mit der Seek-Methode des Ausgabestreams steuern, an welcher Stelle du die Daten schreiben möchtet. Wenn du später dann die Verbindungen parallel aufbaust, kannst du z. B. die Mutex-Klasse verwenden, um zu verhindern, dass mehrere Threads gleichzeitig auf den Ausgabestream zugreifen wollen. Außerdem kannst du dir die BinaryReader/-Writer sparen, wenn du sowieso nur direkt einzelne Bytes schreibst.

    Ich weiß zwar immer ncht wo das Problem lag, habe aber den Code gerade umgeschrieben, um zu hören was ihr davon haltet.
    Ich wollte ihn Debuggen und siehe da: er funktioniert?!?
    Das einzige, was ich geändert habe, ist, dass der Code nun ein Multithreadanwendung ist.

    Werde ihn morgen noch fertigstellen und dann in den Sourcecode-Austausch stellen.
    Danke für eure Hilfe & Kritik! Ohne euch hätte ich es nicht so ehrgeizig weiter versucht!

    Mein bisheriger Code:

    VB.NET-Quellcode

    1. Imports System.Net
    2. Imports System.IO
    3. Imports System.Threading
    4. Public Class Download
    5. 'Einstellungen
    6. Public Property DownloadPath As String
    7. Public Property SavePath As String
    8. Public Property SegmentCount As Integer
    9. Public Property BufferSize As Integer
    10. 'Rescourcen
    11. Private Writer As BinaryWriter
    12. Private DoneEvents() As ManualResetEvent
    14. Private Sub SegmentDownload(ByVal sets As Object)
    15. Dim Settings As SegmentSettings = CType(sets, SegmentSettings)
    16. 'Downlaod anfordern
    17. Dim Request As HttpWebRequest = CType(HttpWebRequest.Create(Settings.DownloadPath), HttpWebRequest)
    18. Request.AddRange(Settings.StartPoint, Settings.EndPoint)
    19. Dim Response As HttpWebResponse = CType(Request.GetResponse(), HttpWebResponse)
    20. 'Rescourcen
    21. Dim Buffer(Settings.Buffersize - 1) As Byte
    22. Dim n As Integer
    23. Dim Reader As New BinaryReader(Response.GetResponseStream())
    24. Dim Recieved As Long = 0
    26. 'Downloadschleife
    27. Do
    28. SyncLock Writer
    29. 'Writer positionieren
    30. Writer.Seek(CInt(Settings.StartPoint + Recieved), SeekOrigin.Begin)
    32. 'Daten lesen und speichern
    33. n = Reader.Read(Buffer, 0, Settings.Buffersize)
    34. Writer.Write(Buffer, 0, n)
    36. 'Informationen aktualisieren
    37. Recieved += n
    38. End SyncLock
    39. Loop Until n = 0 'Solange Daten gelesen
    41. 'Stream freigeben
    42. Reader.Close()
    43. 'Segment als abgeschlossen melden
    44. DoneEvents(Settings.Index).Set()
    45. End Sub
    47. 'Zum Übertragen der Downloadeinstellungen
    48. Private Structure SegmentSettings
    49. Public DownloadPath As String
    50. Public Buffersize As Integer
    51. Public StartPoint As Long
    52. Public EndPoint As Long
    53. Public Index As Integer
    55. Public Sub New(ByVal path As String, ByVal buffer As Integer, ByVal start As Long, ByVal fin As Long, ByVal id As Integer)
    56. DownloadPath = path
    57. Buffersize = buffer
    58. StartPoint = start
    59. EndPoint = fin
    60. Index = id
    61. End Sub
    63. End Structure
    65. Private Function GetDownloadLength(ByVal uri As String) As Long
    66. Dim Request As HttpWebRequest = CType(HttpWebRequest.Create(uri), HttpWebRequest)
    67. Request.Method = "HEAD"
    68. Return Request.GetResponse.ContentLength
    69. End Function
    71. Public Sub SyncDownload()
    72. 'Downloadgröße empfangen
    73. Dim DownloadLength As Long = GetDownloadLength(DownloadPath)
    74. Debug.Print("Downloadgröße: " & DownloadLength)
    75. 'Stream erstellen
    76. Dim FileStream As New FileStream(SavePath, FileMode.Create)
    77. FileStream.SetLength(DownloadLength)
    78. Writer = New BinaryWriter(FileStream)
    80. 'Download splitten
    81. For i% = 0 To SegmentCount - 1
    82. 'Start- und Endpunkt berechnen
    83. Dim StartS As Integer = CInt(i * (DownloadLength / SegmentCount))
    84. Dim EndS As Integer = CInt((i + 1) * (DownloadLength / SegmentCount))
    85. If i < SegmentCount - 1 Then EndS -= 1
    87. 'DoneEvent erstellen
    88. DoneEvents(i) = New ManualResetEvent(False)
    90. Debug.Print("Segment {0} von {1} bis {2} wird erstellt...", i, StartS, EndS)
    92. 'Segmentdownload in Threadpool einsetzen
    93. ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf SegmentDownload), New SegmentSettings(DownloadPath, BufferSize, StartS, EndS, i))
    94. Next
    96. 'Auf Abschluss des Downloads warten
    97. WaitHandle.WaitAll(DoneEvents)
    99. 'Datei freigeben
    100. Writer.Close()
    101. End Sub
    103. Private DownloadThread As New Thread(AddressOf SyncDownload)
    105. Public Sub Download()
    106. DownloadThread.SetApartmentState(ApartmentState.MTA)
    107. DownloadThread.Start()
    108. End Sub
    110. Public Sub WaitForDownload()
    111. If DownloadThread.IsAlive Then
    112. DownloadThread.Join()
    113. End If
    114. End Sub
    116. Public Sub New(ByVal uri As String, ByVal path As String, ByVal segments As Integer, Optional ByVal buffer As Integer = 65536)
    117. DownloadPath = uri
    118. SavePath = path
    119. SegmentCount = segments
    120. BufferSize = buffer
    122. ReDim DoneEvents(segments - 1)
    123. End Sub
    124. End Class

    Me.Net schrieb:

    Werde ihn morgen noch fertigstellen und dann in den Sourcecode-Austausch stellen.
    Das würde ich bei dem derzeitigen Stand des Codes mal lieber sein lassen, da wirst Du (zu Recht) zerrissen.

    Ein paar Anmerkungen:
    - wenn der 'Head' Request -1 zurückgibt oder der Server den Range Header nicht unterstützt gibt es Müll
    - Streams sollten nicht dazu dienen 'aufbewahrt' zu werden, sondern sie werden (mit Using) geöffnet, verarbeitet und sofort wieder geschlossen
    - die ganze Array-Speicherung ist umständlich und überflüssig
    - genauso die Settings-Stucture
    - ob man für den Thread einen aus dem Threadpool oder einen Threading.Thread nimmt ist hier Stilfrage, ich würde den Threading.Thread bevorzugen
    - mit dem Writer.Seek verlierst Du wieder viel Zeit , die Du mit dem segmentierten Download eigentlich gewinnen wolltest
    - die Idee einen Segementierten Download zur Verfügun zu stellen taugt nur wenn sie in einer Klasse gekapselt ist


    Vorschlag:
    - mach eine eingene Klasse FileDownload mit der Methode Download(url as string, path as String)
    - die Methode muss erst einmal ermitteln ob der Server ein Resume unterstützt: ein Head Request gibt laut Http Specification in diesem Fall den StatusCode 206(=Partial Content) zurück
    - wenn der Server das unterstützt , so wird die Datei segementiert geladen, ansonsten konventionell
    - optimal wären die Async Methoden des httpWebRequests, wenn das Dir zu kompliziert ist so nimm den Threading Weg
    - im Thread lade die Bytes und zwar richtig (abhängig von der Buffersize Property/Constant), momentan ist das falsch
    - gib pro thread das Segment mit SequenceNummer und Buffer per Event zurück
    - die Hauptlogik scheibt dann mit dem Writer das Segment sofort raus wenn es das Nächste in der Folge ist, ansonsten wird es in einer temporären Liste zwischengespeichert

    Ich versuch mal deine Vorschläge ab zu arbeiten:
    - Headrequest und Range Konpatiplität zu prüfen hatte ich bereits vor
    - Ich versteh nicht ganz was du mit Arrayspeicherung meinst
    - Die Structure wird durch Threadsichere Propertys ersetzt
    - Werd es in eine Klasse kapseln
    - Was meinst du mit Bytes richtig laden? Ich kopiere sie doch nur Päckchenweise von Stream des Response in den Filestream.
    - Wenn ich das Schreiben in die Hauptlogik nehme und nach deinem Vorschlag bearbeite, speichere ich doch die einzelnen Segmente wieder zwischen, was du oben als schlecht bezeichnet hast

    Hoffe du hilfst mir weiter den Code zu verbessern.

    Halbzeit in Istanbul.

    Me.Net schrieb:

    Ich versteh nicht ganz was du mit Arrayspeicherung meinst
    Ich bezog mich da eher auf Deinen Anfangscode: dort hast Du statt Segmenten (=Bytes) offene Streams (BinaryReadser) gespeichert.

    Me.Net schrieb:

    speichere ich doch die einzelnen Segmente wieder zwischen, was du oben als schlecht bezeichnet hast
    Wie gesagt hast Du Streams statt Byte zwischengespeichert. Beim Threading hast Du das Problem, daß ein Byte-Segment n eher fertig ist als das eigentlich vorausgehend, insofern brauchst Du eine Art Sequence-Nummer. Speicherst Du erst alles zwischen und schreibst dann, so sprengt es Dir bei grossen Dateien den Arbeitsspeicher. Daher immer nur die Bytes speichern, die Du nicht sofort wegschreiben kannst. Danach werden sie aus der List rausgenommen.

Facebook
Telefonspende