Servus und Hallo,
der Titel klingt schon gruselig, aber bevor ich hier zerrissen werde, lasst mich erklären, was es damit auf sich hat. Wir verwenden hier Client/Server-Applikationen, die über ClientDatasets/DataProvider miteinander kommunizieren. Über spezifische DataRequests erhalten wir Daten in einer Key/Value-StringList. Alles andere erfolgt unmittelbar über die Anbindung an die Datenbank.
Bislang haben wir, wenn wir Logdateien von Kundenrechnern zur Auswertung von Fehlern oder der allgemeinen Performance benötigten, eine Netzwerkverbindung zum Kundenserver aufgebaut und die Dateien mittels Windows zu uns kopiert. Dank Conficker, der sich auch über diese Ports verbreiten konnte, halten unsere Admins nun diese Ports geschlossen, dennoch benötigen wir immer wieder diese Dateien.
Nun ja, mein Ansatz ist nun, die Dateien auch über einen DataRequest zu kopieren. Auf Server-Seite öffne ich die Datei mittels FileStream, lese einen Block (Chunk) ein und schicke diesen mit dem DataRequest zurück an den Client, der schreibt die Daten in einen eigenen FileStream und das geschieht so lange, bis die komplette Datei gelesen ist.
Das Einlesen gelingt ohne Probleme:
Delphi-Quellcode:
procedure TMyDataModule.do_DRQ_CopyFile(
const aCommand:
String;
const aParameters: TStringList;
const aResult: TStringList);
var
loc_fs: TFileStream;
loc_s:
String;
loc_s2:
String;
loc_i: Integer;
loc_chunk: Integer;
begin
aResult.Values[aCommand] := '
F';
loc_fs := TFileStream.Create(aParameters.Values['
FileName'], fmOpenRead
or fmShareDenyWrite);
try
aResult.Values['
FileSize'] := IntToStr(loc_fs.Size);
loc_fs.Seek(StrToIntDef(aParameters.Values['
Position'], 0), soFromBeginning);
loc_chunk := loc_fs.Size - loc_fs.Position;
if (64 * ONE_KILOBYTE < loc_chunk)
then
loc_chunk := 64 * ONE_KILOBYTE;
SetLength(loc_s, loc_chunk);
loc_fs.
Read(loc_s[1], loc_chunk);
aResult.Values['
BytesRead'] := IntToStr(loc_chunk);
{ Erste Möglichkeit: Kopieren als String }
aResult.Values['
Data'] := loc_s;
{ Zweite Möglichkeit: Kopieren der ASCII-Werte }
// for loc_i := 1 to loc_chunk do
// loc_s2 := loc_s2 + IntToStr(Ord(loc_s[loc_i])) + ';';
// loc_s2 := Copy(loc_s2, 1, Length(loc_s2) - 1);
// aResult.Values['Data'] := loc_s2;
aResult.Values[aCommand] := '
T';
finally
FreeAndNil(loc_fs);
end;
end;
Möglichkeit 1 war mein ursprünglicher Plan, der verursacht aber auf der Client-Seite Probleme, auf die ich später eingehe.
Möglichkeit 2 umgeht das Problem mit den im String "gespeicherten" Steuerzeichen, ist aber unglaublich zeitaufwändig.
Auf Clientseite sieht das dann wie folgt aus:
Delphi-Quellcode:
function TLogBrowser.DownloadDRQ: Boolean;
var
loc_fs: TFileStream;
loc_Position: Integer;
loc_FileSize: Integer;
loc_drq: String;
loc_v: Variant;
loc_sl: TStringList;
loc_Result: Boolean;
begin
FCancelled := False;
loc_sl := TStringList.Create;
try
loc_FileSize := 0;
loc_Position := 0;
if FileExists(GetTempDir + ExtractFileName('C:\DummyFile.txt')) then
loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmOpenWrite)
else
loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmCreate);
try
loc_fs.Seek(0, soBeginning);
repeat
loc_drq := 'CMD=' + DRQ_CopyFile + ',' +
'FileName=' + 'C:\DummyFile.txt' + ',' +
'Position=' + IntToStr(loc_Position);
loc_v := cdsFiles.DataRequest(loc_drq);
loc_Result := DataRequestResult(DRQ_CopyFile, loc_v, loc_sl);
if (loc_Result) then begin
loc_FileSize := StrToIntDef(loc_sl.Values['FileSize'], 0);
loc_fs.WriteBuffer(Pointer(loc_sl.Values['Data'])^, StrToIntDef(loc_sl.Values['BytesRead'], 0));
Inc(loc_Position, StrToIntDef(loc_sl.Values['BytesRead'], 0));
end;
until (not loc_Result) or (loc_Position >= loc_FileSize);
finally
FreeAndNil(loc_fs);
end;
finally
FreeAndNil(loc_sl);
end;
Result := loc_Result;
end;
Bei dieser Variante scheint zunächst alles zu funktionieren, aber: beim Schreiben des FileStreams werden ab dem ersten Zeilenumbruch oder dem ersten #0 Zeichen nur noch #0 Zeichen geschrieben. Dadurch sind die "kopierten" Daten natürlich vollkommen "wertlos".
Bei der zweiten Variante, bei der ich die
ASCII- Werte übertrage, funktioniert zwar alles wie geplant, aber es ist seeeeeeeeehr zeitraubend. (2 MB benötigen dann knapp 30 Sekunden).
Delphi-Quellcode:
function TLogBrowser.DownloadDRQ: Boolean;
var
loc_j: Integer;
loc_fs: TFileStream;
loc_Position: Integer;
loc_FileSize: Integer;
loc_drq: String;
loc_buffer: array [0.. 64 * ONE_KILOBYTE] of Byte;
loc_sl2: TStringList;
loc_v: Variant;
loc_sl: TStringList;
loc_Result: Boolean;
begin
FCancelled := False;
loc_sl := TStringList.Create;
try
loc_FileSize := 0;
loc_Position := 0;
if FileExists(GetTempDir + ExtractFileName('C:\DummyFile.txt')) then
loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmOpenWrite)
else
loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmCreate);
try
loc_fs.Seek(0, soBeginning);
loc_sl2 := TStringList.Create;
try
repeat
loc_drq := 'CMD=' + DRQ_CopyFile + ',' +
'FileName=' + 'C:\DummyFile.txt' + ',' +
'Position=' + IntToStr(loc_Position);
loc_v := cdsFiles.DataRequest(loc_drq);
loc_Result := DataRequestResult(DRQ_CopyFile, loc_v, loc_sl);
if (loc_Result) then begin
loc_FileSize := StrToIntDef(loc_sl.Values['FileSize'], 0);
StrToStrings(loc_sl.Values['Data'], CON_FieldSep, loc_sl2, False);
for loc_j := 0 to loc_sl2.Count - 1 do
loc_buffer[loc_j] := StrToInt(loc_sl2[loc_j]);
loc_fs.WriteBuffer(loc_buffer, StrToIntDef(loc_sl.Values['BytesRead'], 0));
loc_fs.WriteBuffer(Pointer(loc_sl.Values['Data'])^, StrToIntDef(loc_sl.Values['BytesRead'], 0));
Inc(loc_Position, StrToIntDef(loc_sl.Values['BytesRead'], 0));
end;
until (not loc_Result) or (loc_Position >= loc_FileSize);
finally
FreeAndNil(loc_sl2);
end;
finally
FreeAndNil(loc_fs);
end;
finally
FreeAndNil(loc_sl);
end;
Result := loc_Result;
end;
Die Hilfsfunktion DataRequestResult schreibt den Inhalt der Variant-Variable in eine Key/Value-StringList und wertet das Ergebnis des Paares mit dem Namen der DataRequest-Konstante aus. Wenn dieses 'T' ist, gibt die Funktion True zurück.
Die Hilfsfunktion StrToStrings stammt aus der JCL-Library. Sie wandelt einen String in eine Stringliste um. Dabei wird der übergebene Separator als Trennzeichen genutzt.
procedure StrToStrings(S: String; Sep: String; const List: TStrings; const AllowEmptyString: Boolean);
Hat von Euch jemand eine Idee, was in der ersten Variante verbessert werden kann, so dass diese nutzbar wird? Oder einen Vorschlag, was ich verändern kann, um die zweite Variante drastisch zu beschleunigen? (Ich habe schon mit unterschiedlich großen Datenmengen gearbeitet, was aber kaum einen Unterschied bewirkte).
Vielen Dank schon einmal im Voraus
C.
Sprachen und Entwicklungsumgebungen
Antwort
25. Mai 2009, 15:35
Zitat
: 
und dann klappt's auch mit dem Nachbarn 
Linear-Darstellung
