From: Brandon McGinty on
All,
I have researched this both in the python documentation, and via google.
Neither subprocess nor os.popen* will do what I need.
First, I would instanshiate an ongoing shell, that would remain active
throughout the life of the socket connection.
I am trying to take commands, coming in from a standard python socket,
modify them, and then send them onto this shell, /bin/bash, for example.
The output of these modified commands will be received from the shell,
and sent back through the socket, possibly being modified further.
The connection on the other end of the socket will send multiple
commands, and will need output for each.
Both subprocess and os.popen* only allow inputput and output one time,
and the output to be read only when the process terminates.
I need input and output to be read and written continuously, during the
lifetime of the shell.
I hope this makes sense, and if not, I shall do my best to elaborate
further.
I appreciate all the help this group has given me in the past, and I
certainly appreciate any help you all can offer now.

Sincerely,
Brandon McGinty
From: Ian Kelly on
On Wed, Jun 16, 2010 at 2:29 PM, Brandon McGinty
<brandon.mcginty(a)gmail.com> wrote:
> Both subprocess and os.popen* only allow inputput and output one time, and
> the output to be read only when the process terminates.

You can read output before the subprocess terminates by setting the
pipe to be non-blocking:

import fcntl
import os
import subprocess

>>> process = subprocess.Popen("cat", stdin=subprocess.PIPE, stdout=subprocess.PIPE)
>>> flags = fcntl.fcntl(process.stdout, fcntl.F_GETFL)
>>> fcntl.fcntl(process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
0
>>> process.stdin.write('line1\n')
>>> process.stdout.read()
'line1\n'
>>> process.stdin.write('line2\n')
>>> process.stdout.read()
'line2\n'

Cheers,
Ian
From: Stephen Hansen on
On 6/16/10 1:29 PM, Brandon McGinty wrote:
> Both subprocess and os.popen* only allow inputput and output one time,
> and the output to be read only when the process terminates.

Its not that subprocess only *allow* input and output one at a time, but
that it a) provides blocking file objects by default, and b) those only
read until EOF.

It also provides *convenience* methods for the common case of writing
output once and receiving everything back, but that's not the only way
you can use it.

If you want a bidirectional write/read for awhile, you really just need
to switch those file objects to non-blocking and such.

I found this useful when I needed to do it:
http://code.activestate.com/recipes/440554/

--

Stephen Hansen
... Also: Ixokai
... Mail: me+list/python (AT) ixokai (DOT) io
... Blog: http://meh.ixokai.io/

From: Thomas Jollans on
On 06/16/2010 10:29 PM, Brandon McGinty wrote:
> All,
> I have researched this both in the python documentation, and via google.
> Neither subprocess nor os.popen* will do what I need.
> First, I would instanshiate an ongoing shell, that would remain active
> throughout the life of the socket connection.
> I am trying to take commands, coming in from a standard python socket,
> modify them, and then send them onto this shell, /bin/bash, for example.
> The output of these modified commands will be received from the shell,
> and sent back through the socket, possibly being modified further.
> The connection on the other end of the socket will send multiple
> commands, and will need output for each.
> Both subprocess and os.popen* only allow inputput and output one time,

Is that a fact?

Does this not work:

>>> from subprocess import Popen, PIPE
>>> cat = Popen(["cat"], stdin=PIPE, stdout=PIPE)
>>> cat.stdin.write("hello, world!\n")
>>> cat.stdout.readline()
'hello, world!\n'
>>> cat.stdin.write("and another line\n")
>>> cat.stdout.readline()
'and another line\n'
>>>


> and the output to be read only when the process terminates.
> I need input and output to be read and written continuously, during the
> lifetime of the shell.
> I hope this makes sense, and if not, I shall do my best to elaborate
> further.
> I appreciate all the help this group has given me in the past, and I
> certainly appreciate any help you all can offer now.
>
> Sincerely,
> Brandon McGinty

From: Brandon McGinty on
Ah. Thank you all for your quick responses. I shall implement
non-blocking stdin/stdout objects, then.

Thank You,
Brandon McGinty



On 6/16/2010 5:37 PM, Thomas Jollans wrote:
> On 06/16/2010 10:29 PM, Brandon McGinty wrote:
>> All,
>> I have researched this both in the python documentation, and via google.
>> Neither subprocess nor os.popen* will do what I need.
>> First, I would instanshiate an ongoing shell, that would remain active
>> throughout the life of the socket connection.
>> I am trying to take commands, coming in from a standard python socket,
>> modify them, and then send them onto this shell, /bin/bash, for example.
>> The output of these modified commands will be received from the shell,
>> and sent back through the socket, possibly being modified further.
>> The connection on the other end of the socket will send multiple
>> commands, and will need output for each.
>> Both subprocess and os.popen* only allow inputput and output one time,
>
> Is that a fact?
>
> Does this not work:
>
>>>> from subprocess import Popen, PIPE
>>>> cat = Popen(["cat"], stdin=PIPE, stdout=PIPE)
>>>> cat.stdin.write("hello, world!\n")
>>>> cat.stdout.readline()
> 'hello, world!\n'
>>>> cat.stdin.write("and another line\n")
>>>> cat.stdout.readline()
> 'and another line\n'
>>>>
>
>
>> and the output to be read only when the process terminates.
>> I need input and output to be read and written continuously, during the
>> lifetime of the shell.
>> I hope this makes sense, and if not, I shall do my best to elaborate
>> further.
>> I appreciate all the help this group has given me in the past, and I
>> certainly appreciate any help you all can offer now.
>>
>> Sincerely,
>> Brandon McGinty
>