Comience dos procesos y conéctelos con un conducto en Delphi

Question

Tengo que iniciar dos programas externos en mi programa y conectar el STDOUT del primero al STDIN del segundo programa. ¿Cómo se puede lograr esto en Delphi (RAD Studio 2009, si es importante)? Estoy operando en el entorno de Windows.

Como comandos comando mi situación sería algo como esto:

dumpdata.exe | encrypt.exe "mydata.dat" 

Answer 1

Una prueba rápida que parece funcionar (inspirado en gran medida por JCL):

child1: decir 'Hola, mundo!' 3x a la salida estándar

program child1; 

{$APPTYPE CONSOLE} 

uses 
    SysUtils; 

procedure Main; 
var 
    I: Integer; 
begin 
    for I := 0 to 2 do 
    Writeln('Hello, world!'); 
    Write(^Z); 
end; 

begin 
    try 
    Main; 
    except 
    on E: Exception do 
    begin 
     ExitCode := 1; 
     Writeln(ErrOutput, Format('[%s] %s', [E.ClassName, E.Message])); 
    end; 
    end; 
end. 

child2: echo lo que viene en la entrada estándar a OutputDebugString (pueden ser vistos por DebugView)

program child2; 

{$APPTYPE CONSOLE} 

uses 
    Windows, SysUtils, Classes; 

procedure Main; 
var 
    S: string; 
begin 
    while not Eof(Input) do 
    begin 
    Readln(S); 
    if S <> '' then 
     OutputDebugString(PChar(S)); 
    end; 
end; 

begin 
    try 
    Main; 
    except 
    on E: Exception do 
    begin 
     ExitCode := 1; 
     Writeln(ErrOutput, Format('[%s] %s', [E.ClassName, E.Message])); 
    end; 
    end; 
end. 

padres: lanzamiento child1 redirigido a CHILD2

program parent; 

{$APPTYPE CONSOLE} 

uses 
    Windows, Classes, SysUtils; 

procedure ExecutePiped(const CommandLine1, CommandLine2: string); 
var 
    StartupInfo1, StartupInfo2: TStartupInfo; 
    ProcessInfo1, ProcessInfo2: TProcessInformation; 
    SecurityAttr: TSecurityAttributes; 
    PipeRead, PipeWrite: THandle; 
begin 
    PipeWrite := 0; 
    PipeRead := 0; 
    try 
    SecurityAttr.nLength := SizeOf(SecurityAttr); 
    SecurityAttr.lpSecurityDescriptor := nil; 
    SecurityAttr.bInheritHandle := True; 
    Win32Check(CreatePipe(PipeRead, PipeWrite, @SecurityAttr, 0)); 

    FillChar(StartupInfo1, SizeOf(TStartupInfo), 0); 
    StartupInfo1.cb := SizeOf(TStartupInfo); 
    StartupInfo1.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES; 
    StartupInfo1.wShowWindow := SW_HIDE; 
    StartupInfo1.hStdInput := GetStdHandle(STD_INPUT_HANDLE); 
    StartupInfo1.hStdOutput := PipeWrite; 
    StartupInfo1.hStdError := GetStdHandle(STD_ERROR_HANDLE); 

    FillChar(StartupInfo2, SizeOf(TStartupInfo), 0); 
    StartupInfo2.cb := SizeOf(TStartupInfo); 
    StartupInfo2.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES; 
    StartupInfo2.wShowWindow := SW_HIDE; 
    StartupInfo2.hStdInput := PipeRead; 
    StartupInfo2.hStdOutput := GetStdHandle(STD_OUTPUT_HANDLE); 
    StartupInfo2.hStdError := GetStdHandle(STD_ERROR_HANDLE); 

    FillChar(ProcessInfo1, SizeOf(TProcessInformation), 0); 
    FillChar(ProcessInfo2, SizeOf(TProcessInformation), 0); 

    Win32Check(CreateProcess(nil, PChar(CommandLine2), nil, nil, True, NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo2, 
     ProcessInfo2)); 

    Win32Check(CreateProcess(nil, PChar(CommandLine1), nil, nil, True, NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo1, 
     ProcessInfo1)); 

    WaitForSingleObject(ProcessInfo2.hProcess, INFINITE); 
    finally 
    if PipeRead <> 0 then 
     CloseHandle(PipeRead); 
    if PipeWrite <> 0 then 
     CloseHandle(PipeWrite); 
    if ProcessInfo2.hThread <> 0 then 
     CloseHandle(ProcessInfo2.hThread); 
    if ProcessInfo2.hProcess <> 0 then 
     CloseHandle(ProcessInfo2.hProcess); 
    if ProcessInfo1.hThread <> 0 then 
     CloseHandle(ProcessInfo1.hThread); 
    if ProcessInfo1.hProcess <> 0 then 
     CloseHandle(ProcessInfo1.hProcess); 
    end; 
end; 

procedure Main; 
begin 
    ExecutePiped('child1.exe', 'child2.exe'); 
end; 

begin 
    try 
    Main; 
    except 
    on E: Exception do 
    begin 
     ExitCode := 1; 
     Writeln(Error, Format('[%s] %s', [E.ClassName, E.Message])); 
    end; 
    end; 
end. 

Answer 2

Este enfoque debería funcionar. Antes de preocuparse por llamarlo desde Delphi, obtenga la línea de comando elaborada ejecutándose en una ventana de símbolo del sistema (ventana de DOS).
Luego solo llame a ese comando desde Delphi con WinExec o ShellExecute. Hay opciones para llamar y esperar, o simplemente "disparar y olvidar".

Answer 3

CreateProcess() le permite redirigir tanto stdin como stdout de la aplicación iniciada. Su aplicación puede leer desde la primera extensión de la aplicación y escribir en la segunda aplicación stdin.

Answer 4

Aquí es el código corregido para trabajar en Delphi XE. Las cadenas de línea de comandos deben ser variables y también definidas arriba de la función EjecutarPublicidad.

program Parent; 

    {$APPTYPE CONSOLE} 

    uses 
     Windows, SysUtils, Classes; 

    var cmd1, cmd2 :string; 

    function ExecutePiped(CommandLine1: string; CommandLine2: string):string; 
    var 
     StartupInfo1, StartupInfo2 : TStartupInfo; 
     ProcessInfo1, ProcessInfo2 : TProcessInformation; 
     SecurityAttr    : TSecurityAttributes; 
     PipeRead, PipeWrite  : THandle; 
     Handle      : Boolean; 
     WorkDir     : String; 
    begin 
     PipeWrite := 0; 
     PipeRead := 0; 
     try 
     SecurityAttr.nLength    := SizeOf(SecurityAttr); 
     SecurityAttr.bInheritHandle  := True; 
     SecurityAttr.lpSecurityDescriptor := nil; 

     CreatePipe(PipeRead, PipeWrite, @SecurityAttr, 0); 

     FillChar(StartupInfo1, SizeOf(TStartupInfo), 0); 
     StartupInfo1.cb   := SizeOf(TStartupInfo); 
     StartupInfo1.dwFlags  := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES; 
     StartupInfo1.wShowWindow := SW_HIDE; 
     StartupInfo1.hStdInput := GetStdHandle(STD_INPUT_HANDLE); 
     StartupInfo1.hStdOutput := PipeWrite; 
     StartupInfo1.hStdError := GetStdHandle(STD_ERROR_HANDLE); 

     FillChar(StartupInfo2, SizeOf(TStartupInfo), 0); 
     StartupInfo2.cb   := SizeOf(TStartupInfo); 
     StartupInfo2.dwFlags  := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES; 
     StartupInfo2.wShowWindow := SW_HIDE; 
     StartupInfo2.hStdInput := PipeRead; 
     StartupInfo2.hStdOutput := GetStdHandle(STD_OUTPUT_HANDLE); 
     StartupInfo2.hStdError := GetStdHandle(STD_ERROR_HANDLE); 

     FillChar(ProcessInfo1, SizeOf(TProcessInformation), 0); 
     FillChar(ProcessInfo2, SizeOf(TProcessInformation), 0); 

     WorkDir := ''; 

     Handle := CreateProcess(nil, PChar(CommandLine2), nil, nil, True, 0, nil, PChar(WorkDir), StartupInfo2, ProcessInfo2); 
     Handle := CreateProcess(nil, PChar(CommandLine1), nil, nil, True, 0, nil, PChar(WorkDir), StartupInfo1, ProcessInfo1); 

     WaitForSingleObject(ProcessInfo2.hProcess, INFINITE); 

     finally 

     if PipeRead    <> 0 then CloseHandle(PipeRead); 
     if PipeWrite    <> 0 then CloseHandle(PipeWrite); 

     if ProcessInfo2.hThread <> 0 then CloseHandle(ProcessInfo2.hThread); 
     if ProcessInfo2.hProcess <> 0 then CloseHandle(ProcessInfo2.hProcess); 

     if ProcessInfo1.hThread <> 0 then CloseHandle(ProcessInfo1.hThread); 
     if ProcessInfo1.hProcess <> 0 then CloseHandle(ProcessInfo1.hProcess); 

     end; 

    end; 

    procedure Main; 
    begin 
     cmd1 := '"child1.exe"'; 
     cmd2 := '"child2.exe"'; 
     ExecutePiped(cmd1, cmd2); 
    end; 

    begin 
     try 
     Main; 
     except 
     on E: Exception do 
     begin 
      ExitCode := 1; 
      Writeln(Error, Format('[%s] %s', [E.ClassName, E.Message])); 
     end; 
     end; 
    end. 

Para probar he modificado Child2.pas para escribir el texto recibido en un archivo.

program Child2; 

    {$APPTYPE CONSOLE} 

    uses 
    Windows, SysUtils, Classes; 

    procedure Main; 
    var S: string; 
     OutFile : TextFile; 
    begin 
     AssignFile(OutFile, 'test.txt'); 
     Rewrite(OutFile); 
     while not Eof(Input) do 
     begin 
     Readln(S); 
     Writeln(OutFile,S); 
     //if S <> '' then OutputDebugString(PChar(S)); 
     end; 
     CloseFile(OutFile); 
    end; 

    begin 
     try 
     Main; 
     except 
     on E: Exception do 
     begin 
      ExitCode := 1; 
      Writeln(ErrOutput, Format('[%s] %s', [E.ClassName, E.Message])); 
     end; 
     end; 
    end.