tuberias - ¿Cómo redirigir la salida binaria de gbak a una transmisión Delphi?

tuberias y filtros en linux

Question

Quiero que la herramienta de copia de seguridad de Firebird, gbak, escriba su salida en una secuencia Delphi (sin ningún archivo intermedio). Hay un parámetro de línea de comando para escribir en stdout en lugar de en un archivo. Luego uso el método Execute en JclSysUtils de JEDI para lanzar gbak y procesar ese resultado.

Se parece a esto:

procedure DoBackup;
var
LBackupAbortFlag: Boolean;
LBackupStream: TStringStream;
begin
LBackupAbortFlag := False;
LBackupStream := TStringStream.Create;
try
Execute(''"C:/path to/gbak.exe" -b -t -v -user SYSDBA -pas "pw" <db> stdout'',
LBackupStream.WriteString, // Should process stdout (backup)
SomeMemo.Lines.Append, // Should process stderr (log)
True, // Backup is "raw"
False, // Log is not
@LBackupAbortFlag);
LBackupStream.SaveToFile(''C:/path to/output.fbk'');
finally
LBackupStream.Free;
end;
end;

El problema es que el archivo de salida es demasiado pequeño para contener esa copia de seguridad real. Todavía veo elementos del contenido del archivo. Intenté diferentes tipos de transmisión, pero eso no parece marcar la diferencia. ¿Qué podría estar yendo mal aquí?

Actualizar

Para ser claros: también son bienvenidas otras soluciones. Más que nada, necesito algo confiable. Es por eso que fui con JEDI en primer lugar, no para reinventar tal cosa. Entonces, sería bueno, si no fuera demasiado complicado.

Answer 1

Espero que su código esté fallando porque intenta poner datos binarios a través de una secuencia orientada al texto. En cualquier caso, es bastante simple resolver su problema con un par de llamadas a la API de Win32. No veo ningún motivo convincente para utilizar componentes de terceros solo para esta tarea.

Esto es lo que necesita hacer:

1. Cree una tubería que usará como un canal de comunicación entre los dos procesos.
2. Cree el proceso gbak y organice que su stdout sea el final de escritura de la tubería.
3. Lea desde el final de lectura de la tubería.

Aquí hay un programa de demostración simple:

{$APPTYPE CONSOLE}
uses
SysUtils, Classes, Windows;
procedure ReadOutputFromExternalProcess(const ApplicationName, CommandLine: string; Stream: TStream);
const
PipeSecurityAttributes: TSecurityAttributes = (
nLength: SizeOf(PipeSecurityAttributes);
bInheritHandle: True
);
var
hstdoutr, hstdoutw: THandle;
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
lpApplicationName: PChar;
ModfiableCommandLine: string;
Buffer: array [0..4096-1] of Byte;
BytesRead: DWORD;
begin
if ApplicationName='''' then begin
lpApplicationName := nil;
end else begin
lpApplicationName := PChar(ApplicationName);
end;
ModfiableCommandLine := CommandLine;
UniqueString(ModfiableCommandLine);
Win32Check(CreatePipe(hstdoutr, hstdoutw, @PipeSecurityAttributes, 0));
Try
Win32Check(SetHandleInformation(hstdoutr, HANDLE_FLAG_INHERIT, 0));//don''t inherit read handle of pipe
ZeroMemory(@StartupInfo, SizeOf(StartupInfo));
StartupInfo.cb := SizeOf(StartupInfo);
StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
StartupInfo.wShowWindow := SW_HIDE;
StartupInfo.hStdOutput := hstdoutw;
StartupInfo.hStdError := hstdoutw;
if not CreateProcess(
lpApplicationName,
PChar(ModfiableCommandLine),
nil,
nil,
True,
CREATE_NO_WINDOW or NORMAL_PRIORITY_CLASS,
nil,
nil,
StartupInfo,
ProcessInfo
) then begin
RaiseLastOSError;
end;
CloseHandle(ProcessInfo.hProcess);
CloseHandle(ProcessInfo.hThread);
CloseHandle(hstdoutw);//close the write end of the pipe so that the process is able to terminate
hstdoutw := 0;
while ReadFile(hstdoutr, Buffer, SizeOf(Buffer), BytesRead, nil) and (BytesRead<>0) do begin
Stream.WriteBuffer(Buffer, BytesRead);
end;
Finally
CloseHandle(hstdoutr);
if hstdoutw<>0 then begin
CloseHandle(hstdoutw);
end;
End;
end;
procedure Test;
var
Stream: TFileStream;
begin
Stream := TFileStream.Create(''C:/Desktop/out.txt'', fmCreate);
Try
ReadOutputFromExternalProcess('''', ''cmd /c dir /s C:/Windows/system32'', Stream);
Finally
Stream.Free;
End;
end;
begin
Test;
end.

Answer 2

Mi primera respuesta es efectiva cuando desea fusionar stdout y stderr. Sin embargo, si necesita mantenerlos separados, ese enfoque no sirve de nada. Y ahora puedo ver, a partir de una lectura más cercana de su pregunta y sus comentarios, que desea mantener las dos secuencias de salida separadas.

Ahora, no es completamente sencillo extender mi primera respuesta para cubrir esto. El problema es que el código allí usa bloqueo de E / S. Y si necesita dar servicio a dos tuberías, hay un conflicto obvio. Una solución comúnmente utilizada en Windows es la E / S asíncrona, conocida en el mundo de Windows como E / S superpuesta. Sin embargo, la E / S asíncrona es mucho más compleja de implementar que el bloqueo de E / S.

Por lo tanto, voy a proponer un enfoque alternativo que todavía utilice bloqueo de E / S. Si queremos dar servicio a varios conductos, y queremos usar E / S de bloqueo, la conclusión obvia es que necesitamos un hilo para cada tubería. Esto es fácil de implementar, mucho más fácil que la opción asincrónica. Podemos usar código casi idéntico pero mover los bucles de lectura de bloqueo en hilos. Mi ejemplo, re-trabajado de esta manera, ahora se ve así:

{$APPTYPE CONSOLE}
uses
SysUtils, Classes, Windows;
type
TProcessOutputPipe = class
private
Frd: THandle;
Fwr: THandle;
public
constructor Create;
destructor Destroy; override;
property rd: THandle read Frd;
property wr: THandle read Fwr;
procedure CloseWritePipe;
end;
constructor TProcessOutputPipe.Create;
const
PipeSecurityAttributes: TSecurityAttributes = (
nLength: SizeOf(TSecurityAttributes);
bInheritHandle: True
);
begin
inherited;
Win32Check(CreatePipe(Frd, Fwr, @PipeSecurityAttributes, 0));
Win32Check(SetHandleInformation(Frd, HANDLE_FLAG_INHERIT, 0));//don''t inherit read handle of pipe
end;
destructor TProcessOutputPipe.Destroy;
begin
CloseHandle(Frd);
if Fwr<>0 then
CloseHandle(Fwr);
inherited;
end;
procedure TProcessOutputPipe.CloseWritePipe;
begin
CloseHandle(Fwr);
Fwr := 0;
end;
type
TReadPipeThread = class(TThread)
private
FPipeHandle: THandle;
FStream: TStream;
protected
procedure Execute; override;
public
constructor Create(PipeHandle: THandle; Stream: TStream);
end;
constructor TReadPipeThread.Create(PipeHandle: THandle; Stream: TStream);
begin
inherited Create(False);
FPipeHandle := PipeHandle;
FStream := Stream;
end;
procedure TReadPipeThread.Execute;
var
Buffer: array [0..4096-1] of Byte;
BytesRead: DWORD;
begin
while ReadFile(FPipeHandle, Buffer, SizeOf(Buffer), BytesRead, nil) and (BytesRead<>0) do begin
FStream.WriteBuffer(Buffer, BytesRead);
end;
end;
function ReadOutputFromExternalProcess(const ApplicationName, CommandLine: string; stdout, stderr: TStream): DWORD;
var
stdoutPipe, stderrPipe: TProcessOutputPipe;
stdoutThread, stderrThread: TReadPipeThread;
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
lpApplicationName: PChar;
ModfiableCommandLine: string;
begin
if ApplicationName='''' then
lpApplicationName := nil
else
lpApplicationName := PChar(ApplicationName);
ModfiableCommandLine := CommandLine;
UniqueString(ModfiableCommandLine);
stdoutPipe := nil;
stderrPipe := nil;
stdoutThread := nil;
stderrThread := nil;
try
stdoutPipe := TProcessOutputPipe.Create;
stderrPipe := TProcessOutputPipe.Create;
ZeroMemory(@StartupInfo, SizeOf(StartupInfo));
StartupInfo.cb := SizeOf(StartupInfo);
StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
StartupInfo.wShowWindow := SW_HIDE;
StartupInfo.hStdOutput := stdoutPipe.wr;
StartupInfo.hStdError := stderrPipe.wr;
Win32Check(CreateProcess(lpApplicationName, PChar(ModfiableCommandLine), nil, nil, True,
CREATE_NO_WINDOW or NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo, ProcessInfo));
stdoutPipe.CloseWritePipe;//so that the process is able to terminate
stderrPipe.CloseWritePipe;//so that the process is able to terminate
stdoutThread := TReadPipeThread.Create(stdoutPipe.rd, stdout);
stderrThread := TReadPipeThread.Create(stderrPipe.rd, stderr);
stdoutThread.WaitFor;
stderrThread.WaitFor;
Win32Check(WaitForSingleObject(ProcessInfo.hProcess, INFINITE)=WAIT_OBJECT_0);
Win32Check(GetExitCodeProcess(ProcessInfo.hProcess, Result));
finally
stderrThread.Free;
stdoutThread.Free;
stderrPipe.Free;
stdoutPipe.Free;
end;
end;
procedure Test;
var
stdout, stderr: TFileStream;
ExitCode: DWORD;
begin
stdout := TFileStream.Create(''C:/Desktop/stdout.txt'', fmCreate);
try
stderr := TFileStream.Create(''C:/Desktop/stderr.txt'', fmCreate);
try
ExitCode := ReadOutputFromExternalProcess('''', ''cmd /c dir /s C:/Windows/system32'', stdout, stderr);
finally
stderr.Free;
end;
finally
stdout.Free;
end;
end;
begin
Test;
end.

Si desea agregar soporte para cancelar, simplemente debe agregar una llamada a TerminateProcess cuando el usuario cancela. Esto detendría todo, y la función devolvería el código de salida que proporcionó a TerminateProcess . En este momento, no estoy seguro de sugerirle un marco de cancelación, pero creo que el código en esta respuesta está ahora muy cerca de cumplir con sus requisitos.