Problem mit Freisetzung von FileStream und Frage zum IdHTTP Datei Download

[Sir Rufo]

Ich würde einfach mal den FileStream so erzeugen

Delphi-Quellcode:

fileDatei := TFileStream.Create( 
  strLocalFile, 
  fmCreate or fmOpenReadWrite, 
  fmShareExclusive  );

Dann kann dort auch niemand mehr hineinpfuschen ...

[TiGü]

Zitat:

Zitat von Sir Rufo (Beitrag 1314670)

Ich würde einfach mal den FileStream so erzeugen

Delphi-Quellcode:

fileDatei := TFileStream.Create( 
  strLocalFile, 
  fmCreate or fmOpenReadWrite, 
  fmShareExclusive  );

Dann kann dort auch niemand mehr hineinpfuschen ...

Das stimmt aber nicht, wenn es der gleiche Prozess ist.
Zum Beispiel wenn versehentlich der Thread zweimal gestartet wird.

[Athris]

Hab den Thread Start ins FormCreate verschoben und gleichzeitig den FileStream um das fmShareExclusive erweitert. Fehler taucht weiterhin auf.

Beim DeleteFile dürfte die Meldung nicht auftreten, da dieses nur ein einziges mal aufgerufen wird. Die Meldung kommt aber während des Downloads, also während den Durchlauf im Repeat Bereich. Ich denke eher dass es am FileStream also konrekt hier dran liegt:

Delphi-Quellcode:

        if not FileExists(strLocalFile) then begin
          fileDatei := TFileStream.Create(strLocalFile, fmCreate, fmShareExclusive );
        end
        else begin
          fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite, fmShareExclusive );
          flgexit := fileDatei.Size >= intLength;
          if not flgexit then
            fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
        end;

[Athris]

Kurzer Nachtrag:
Virenscanner ist es definitiv nicht. Habe das Programm gerade auf einem nackten Server ausgeführt und die Meldung tritt immer noch auf. Ich habe irgendwie das Gefühl dass der unter bestimmten Umständen die Datei nicht korrekt schließt und beim nächsten Durchgang wo er das nächste Teilstück herunterladen möchte, die Datei nicht öffnen kann.

[frankyboy1974]

hallo,

ich verstehe nicht warum dieser code

Delphi-Quellcode:

fileDatei:=nil;
if not FileExists(strLocalFile) then begin
 fileDatei := TFileStream.Create(strLocalFile, fmCreate);
end else begin
   fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);

innerhalb der Schleife steht (oder wie auch immer du das mittlerweilen geändert hast). Würde es nicht reichen, wenn du einmal überprüfst, ob die Datei bereits vorhanden ist?

mfg

[Athris]

Wenn das Programm das erste mal startet und der das erste mal in die Schleife reinläuft dann existiert die Datei nicht und der Filestream erstellt eine neue leere Dateihülle die im Anschluss mit 50000 Bytes gefüllt wird. Dann ist der erste Teil der Datei abgeschlossen und es geht wieder von vorne los. Nun haben wir ja bereits ein Teilstück der Datei, deswegen wird die vorhandene Datei geöffnet und an das Ende angesetzt. Das Programm lädt nun die nächsten 50000 Bytes. Das ganze geht dann solange bis die Datei komplett auf der Festplatte ist.

Wiegesagt ich würde auch gerne die Datei in einem Rutsch herunterladen. Dann habe ich aber das Problem, dass die wenn der Downloadprozess irgendwie unterbrochen wird, auf der Festplatte diese "halb gedownloadete" Datei liegt. Dieses Fragment hat aber bereits die volle Größe erhalten.
Beispiel:
Heruntergeladen wird eine 10MB Datei.
Filestream erstellt die Hülle mit Größe 0.
IdHTTP holt sich die 10MB Datei aus dem Internet und setzt damit die Größe der Hülle auf 10MB.
Während des Downloads schmiert der Rechner ab. Bisher wurden 6,5 MB heruntergeladen.
Beim nächsten Start prüft das Programm die lokale Dateigröße gegen die Webgröße. Beide sind identisch, da die lokale Dateihülle 10 MB hat, obwohl die Datei noch gr nicht voll heruntergeladen wurde.

[nahpets]

Bin mal ein bisserl naiv, weil ich's nicht so recht verstehe.
Auf die Datei zugegriffen wird doch eigentlich (hauptsächlich) hier:

Delphi-Quellcode:

        IdDateiDownload.Get(strUrl, fileDatei);
        finally
          fileDatei.Free;

Get schreibt und bei Free wird zugemacht. Passiert das eventuell zu schnell? Mach doch bitte mal (probehalber) hinter das

Delphi-Quellcode:

IdDateiDownload.Get(strUrl, fileDatei);

noch ein

Delphi-Quellcode:

Sleep(1000)

. Außer, dass es langsamer wird, ändert sich dann was?
(Frei nach dem Motto: Beim Debuggen passiert es nicht, weil Du da zwangsläufig langsamer bist?)
Zugegebenermaßen ist mein Gedankengang etwas schräg, denn es würde ja bedeuten, dass das id.Get noch nicht mit dem Schreiben fertig ist, während die Datei bereits geschlossen wurde, was in dem Fall aber nicht funktionieren kann.

Alternative Fehlermöglichkeit:

Die Datei wird im free geschlossen. Das Betriebssystem hat also ein bisserl was zu tuen.
In der Schleife geht es aber am Anfang schon munter weiter, die Datei ist da und soll zum Schreiben geöffnet werden, aber das Betriebssystem hat sie noch "zwischen".

Daher bitte mal hier ändern:

Delphi-Quellcode:

       if not FileExists(strLocalFile) then begin
          fileDatei := TFileStream.Create(strLocalFile, fmCreate);
        end
        else begin
          fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);
          flgexit := fileDatei.Size >= intLength;
          if not flgexit then
            fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
        end;

in

Delphi-Quellcode:

       if not FileExists(strLocalFile) then begin
          fileDatei := TFileStream.Create(strLocalFile, fmCreate);
        end
        else begin
          try
            fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);
          except
            on e : Exception do begin
              ShowMessage(Format('Upps, hier tritt der Fehler auf: %s',[e.Message]);
            end;
          end;
          flgexit := fileDatei.Size >= intLength;
          if not flgexit then
            fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
        end;

Kommt diese Fehlermeldung, dann bau (erstmal) um das TFileStream.Create eine Schleife, in der Du, mit kurzer Pause, 3 (oder so ähnlich) Versuche machst, die Datei zu öffnen. Sowas in der Art:

Delphi-Quellcode:

       if not FileExists(strLocalFile) then begin
          fileDatei := TFileStream.Create(strLocalFile, fmCreate);
        end
        else begin
          for i := 1 to 3 do begin
            try
              fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);
              break;
            except
              on e : Exception do begin
                if i = 3 then Raise else Sleep(1000);
              end;
            end;
          end;
          flgexit := fileDatei.Size >= intLength;
          if not flgexit then
            fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
        end;

Im Zweifelsfalle baue bitte in die Routine mehr Try-Except-Blöcke ein, um die exakte Fehlerstelle zu finden. So ist das doch eher wie mit der :glaskugel:

@frankyboy1974, der Code dürfte innerhalb der Schleife sein, weil das fmCreate nur beim ersten Mal erforderlich ist und dann immer fmOpenReadWrite. Man muss aber irgendwo die Entscheidung treffen und das erscheint mir eine sinnvolle Stelle zu sein.

Alternativ könnte man natürlich auch vor der Schleife prüfen, ob die Datei vorhanden ist, wenn nein, erstellt man eine leere Datei und schließt sie.
In dem Fall kann man dann innerhalb der Schleife davon ausgehen, dass sie immer da ist und spart sich
innerhalb der Schleife des "ewige"

Delphi-Quellcode:

if not FileExists(strLocalFile) then begin

. Also ungefähr so:

Delphi-Quellcode:

        fileDatei:=nil;
        if not FileExists(strLocalFile) then begin
          fileDatei := TFileStream.Create(strLocalFile, fmCreate);
          fileDatei.Free;
        end;

    fileDatei:=nil;
    repeat
       fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);
       flgexit := fileDatei.Size >= intLength;
       if not flgexit then
          fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
       end;

[frankyboy1974]

hallo,

wenn ich in einer fussgesteuert Schleife einmal eine Entscheidung treffen muss, tue ich das vorher. Ich würde vermuten, er gibt die Datei zwar frei, dies dauert aber unter Umständen zu lange, und beim nächsten Reservieren läuft das ggf. Programm in einen Fehler. Wenn er nun nur einmal das Handle (vor der Schleife) auf die Datei holt, funktioniert es.


mfg

[nahpets]

Zitat:

Zitat von frankyboy1974 (Beitrag 1314717)

hallo,

wenn ich in einer fussgesteuert Schleife einmal eine Entscheidung treffen muss, tue ich das vorher. Ich würde vermuten, er gibt die Datei zwar frei, dies dauert aber unter Umständen zu lange, und beim nächsten Reservieren läuft das ggf. Programm in einen Fehler. Wenn er nun nur einmal das Handle (vor der Schleife) auf die Datei holt, funktioniert es.


mfg

Jo, dem is nix hinzuzufügen.
Du meinst also in etwas so:

Delphi-Quellcode:

procedure TUpdateThread.DateiDownload(strUrl, strLocalFile:String);
var
  flgexit:Boolean;
  intLength, intRangeEnd, intStartLength: Int64;
  IdDateiDownload: TIdHTTP;
  fileDatei: TFileStream;
begin
  IdDateiDownload := TIdHTTP.Create(nil);
  fileDatei:=nil;
  try
    try
      IdDateiDownload.ConnectTimeout := 10000;
      IdDateiDownload.ReadTimeout := 10000;
      IdDateiDownload.Head(strUrl);
      intStartLength := 0;
      intLength := IdDateiDownload.Response.ContentLength;

      //Ermittel die Startgröße
      if FileExists(strLocalFile) then begin
        fstrProtText := 'Die '+strLocalFile+' Datei existiert bereits und wird nun gelöscht';
        fflgProtCaption := false;
        Synchronize(AddProt);
        DeleteFile(strLocalFile);
      end;

      //Setze die Progressbar
      fintProgressStartPosition := intStartLength;
      fintProgressMaxPosition := intLength;
      Synchronize(MainDownloadProgressBegin);

      fstrProtText := 'Lade die Datei '+ExtractFileName(strLocalFile)+' herunter';
      fflgProtCaption := true;
      Synchronize(AddProt);

      flgexit := false;

      fileDatei:=nil;
      if not FileExists(strLocalFile) then begin
        fileDatei := TFileStream.Create(strLocalFile, fmCreate);
      end
      else begin
        fileDatei := TFileStream.Create(strLocalFile, fmOpenReadWrite);
      end;

      //Prüfe ob Datei verwendet wird
      repeat
        flgexit := fileDatei.Size >= intLength;
        if not flgexit then
          fileDatei.Seek(Max(0, fileDatei.Size-4096), soFromBeginning);
          intRangeEnd := fileDatei.Size+50000;

          if intRangeEnd < intLength then begin
            IdDateiDownload.Request.Range := IntToStr(fileDatei.Position) + '-'+ IntToStr(intRangeEnd);
          end
          else begin
            IdDateiDownload.Request.Range := IntToStr(fileDatei.Position) + '-';
            flgexit := true;
          end;
          IdDateiDownload.Get(strUrl, fileDatei);
        if intRangeEnd < intLength then begin
          fintProgressPosition := intRangeEnd;
          Synchronize(MainDownloadProgressWork);
        end
        else begin
          fintProgressPosition := intLength;
          Synchronize(MainDownloadProgressWork);
        end;
      until (flgexit OR Terminated);
      fileDatei.Free;
      IdDateiDownload.Disconnect;
    except
      on E : Exception do
      Begin
        MessageDlg('Bei dem Herunterladen von Dateien ist ein Fehler aufgetreten: '+E.Message, mtError, [mbOK], 0);
      end;
    end;
  finally
    IdDateiDownload.Free;
  end;
end;

Wäre eindeutig eleganter.

[frankyboy1974]

hallo,

jupp:thumb: ich habs nicht ausprobiert, aber so könnte ich damit leben und ich würde vermuten, es funktioniert.

mfg