Indy TCPClient Send File to TCPServer Leadng Spaces and a # Character - delphi

Question

I have just started "playing" with Indy. Used this post how to send file from server to client using indy and altered it so that my Client is the one Sending Data to the Server.
Client has following code to send Data :
procedure TForm1.btnConnectClick(Sender: TObject);
begin
TCPClient.Host:='192.168.88.117';
TCPClient.Port:=32832;
TCPClient.Connect;
end;
procedure TForm1.btnSendClick(Sender: TObject);
var
AStream : TFileStream;
begin
if not TCPClient.Connected then Exit;
TCPClient.IOHandler.WriteLn('SEND_FILE '+GetComputerName+FormatDateTime('yyyy-mm-dd_hhnnsszzz',now)+'.txt');
try
AStream := TFileStream.Create(ExtractFilePath(Application.ExeName)+'\1.txt', fmOpenRead or fmShareDenyWrite);
TCPClient.IOHandler.LargeStream := true;
TCPClient.IOHandler.Write(AStream, 0, True);
finally
AStream.Free;
end;
TCPClient.Disconnect; // otherwise the file is locked on the server side
end;
Server has following code to receive Data :
procedure TForm1.TCPServerExecute(AContext: TIdContext);
var
AStream : TFileStream;
cmd, params, filename : string;
begin
params := AContext.Connection.IOHandler.ReadLn();
cmd := Fetch(params);
if cmd = 'SEND_FILE' then
begin
filename := ExtractFileName(params);
TThread.Queue(nil,
procedure
begin
Memo1.Lines.Add('Command '+cmd+' File Name '+filename);
end
);
AStream := TFileStream.Create(ExtractFilePath(Application.ExeName)+'\'+filename, fmCreate);
try
AContext.Connection.IOHandler.LargeStream:=true;
AContext.Connection.IOHandler.ReadStream(AStream, -1, false);
finally
AStream.Free;
end;
end;
end;
It seems to function correctly , I have made two clients for my test and ran them from separate computers , the server was receiving data from both of them and was creating the data correctly.
I have only two Problems :
1. for some reason the File Received on the Server has always the same amount of leading spaces followed by a # symbol.
Original File looks like this
HERE IS SOME STUFF
Received file on Server looks like this :
#HERE IS SOME STUFF
2. It looks like that after every file Send I need to disconnect , otherwise Indy TCPServer keeps the file locked , is this expected behavior ? How can I tell if the File is done ? I will need to process the received files in another Thread one-by-one .
Thank you.
UPDATE 1
So as recommended by Remy I've altered the Server like this :
procedure TForm1.TCPServerExecute(AContext: TIdContext);
var
AStream : TFileStream;
cmd, params, filename : string;
begin
params := AContext.Connection.IOHandler.ReadLn();
cmd := Fetch(params);
if cmd = 'SEND_FILE' then
begin
filename := ExtractFileName(params);
AStream := TFileStream.Create(ExtractFilePath(Application.ExeName)+'\'+filename, fmCreate);
try
AContext.Connection.IOHandler.WriteLn('OK');
AContext.Connection.IOHandler.LargeStream:=true;
AContext.Connection.IOHandler.ReadStream(AStream, -1, false);
finally
AStream.Free;
end;
end;
params := AContext.Connection.IOHandler.ReadLn();
cmd := Fetch(params);
if cmd = 'SENT' then
RenameFile(filename,ChangeFileExt(filename,'.dat'));
end;
On the Client I moved the entire Transfer into a Thread using ITask like this :
procedure TForm1.BackgroundTransfer;
var
TCPClient : TidTCPClient;
AStream : TFileStream;
Files : TStringDynArray;
i : integer;
isDone : boolean;
begin
Files := TDirectory.GetFiles(ExtractFilePath(Application.ExeName)+'\1\','*.out');
TThread.Queue(TThread.CurrentThread,
procedure
begin
Memo1.Lines.Add(IntToStr(Length(Files)));
end
);
if Length(Files) = 0 then Exit;
TCPClient := TidTCPClient.Create(nil);
try
TransferActive:=true;
TCPClient.Disconnect;
TCPClient.Host:='192.168.88.117';
TCPClient.Port:=32832;
TCPClient.Connect;
for i := Low(Files) to High(Files) do
begin
isDone:=false;
if FileExists(Files[i]) = true then
begin
TCPClient.IOHandler.WriteLn('SEND_FILE '+Files[i]);
try
// wait for server
repeat
sleep(100);
if TCPClient.IOHandler.ReadLn() = 'OK' then break;
until ( true );
AStream := TFileStream.Create(Files[i], fmOpenRead or fmShareDenyWrite);
TCPClient.IOHandler.LargeStream := true;
TCPClient.IOHandler.Write(AStream, 0, True);
isDone:=true;
TCPClient.IOHandler.WriteLn('SENT '+Files[i]);
finally
AStream.Free;
end;
if isDone = true then
System.SysUtils.DeleteFile(Files[i]);
end;
end;
finally
TCPClient.Free;
TransferActive:=false;
end;
end;
I Check with a Timer every 10 seconds if the Task is running if not I create a new one like this :
procedure TForm1.Timer2Timer(Sender: TObject);
if TransferActive = false then
begin
inc(ThreadTimer);
Panel1.Caption:=ThreadTimer.ToString;
Panel1.Color:=clRed;
end
else
begin
Panel1.Color:=clGreen;
end;
if ThreadTimer >= 10 then
begin
ThreadTimer:=0;
TransferTask := TTask.Create(BackGroundTransfer);
TransferTask.Start;
end;
end;
If I understood it correctly Indy Keeps Track of the Connections in the Background . Connection A-A , B-B , C-C , they cannot get mixed up . I am asking this because from the Server and Client side I just send OK or SENT and it works . ( hopefully not just by pure luck )
This is important because once it is fully working , I will have multiple client (android devices) sending data to this server . And there will be quiet a high chance that sometimes more then one client will be uploading data.
I also tested this like what happens if I start copying files into the Clients INPUT Directory and the Copy is not Done but the Task start . It worked , on first run it detected 350 files on the next run 500 .
Also tested if I simply stop the Server what happens that works too . If I use the TCPServer.Active:=false;
On the Client side the WriteLn and ReadLn properly causes an Exception ( Server Timeout I guess ) if the connection is lost .
On the Server Side I simply rename the Received file from OUT to DAT once it is done . I am not 100% sure if that guarantees that the file was really 100% correctly transferred . I was however unable to produce a damaged file during my testings.
Anyway the Entire idea is :
TCPClient is running on a Android phone, where the User Scanns Barcodes , I create a control file from this which is then in 10 sec intervals uploaded to the server . And from then on Processed by the Server and sent to another server .
Regards
UPDATE 2
Removed this line from server :
DelFilesFromDir(ExtractFilePath(Application.ExeName), '*.out', FALSE);
was a bad idea to put in inside the Execute method .
I will need to find another way to remove possible junk files .
Also TransferActive is a Global variable , and is being modified by the Transfer Background Thread. But since only one Thread is running at a Time, I thought it should be safe.