Question

I have a problem at hand which requires me to spawn a command prompt as a different process and send some commands to it and capture/parse the command output. This interaction needs to be in the form of a parent-child process where say all the commands can be put in a ruby file and upon running the ruby file, the commands are sent to the console(command prompt) and output is received from it and processed in the ruby script.

The general logic which I would follow is:

1. Spawn a different process by using a fork and get a process id
2. Obtain streams for the process
3. Write to the input stream of the process and read from the output stream.

The environment which I am using is Windows XP machine with Ruby 1.9.2 installed on it. I downloaded the win32-process library found over here. By using that library, I could do step 1 as follows

require 'win32/process'
    APP_NAME = "C:\\Windows\\system32\\cmd.exe"
    process_info = Process.create(:app_name => APP_NAME,
      :creation_flags => Windows::Process::CREATE_NEW_CONSOLE,
      :process_inherit  => false,
      :thread_inherit   => true,
      :cwd => "C:\\"
    )

Since the win32-process library is based on using processes and threads on windows, I tried to go through the MSDN help for it. While reading the Creation of a Console article, I found that the GetStdHandle method could be used to get the handles to the input and output streams. But, i could not find this method implemented anywhere in win32-process.

Can someone provide me with some guidance on how to proceed with steps 2 and 3?

Also, is there any other way which can be used to solve the problem at hand?

Also, I would like to learn more about inter-process communication or in general spawning and forking of processes, so can somebody please tell me some good references where I could study them?

Thanks in advance

Answer 1

Here an example using IO.popen in windows, imo if it works with the stdlib don’t use gems

IO.popen("other_program", "w+") do |pipe|
  pipe.puts "here, have some input"
  pipe.close_write  # If other_program process doesn't flush its output, you probably need to use this to send an end-of-file, which tells other_program to give us its output. If you don't do this, the program may hang/block, because other_program is waiting for more input.
  output = pipe.read
end

# You can also use the return value from your block. (exit code stored in $? as usual)
output = IO.popen("other_program", "w+") do |pipe|
  pipe.puts "here, have some input"
  pipe.close_write
  pipe.read
end