Re: [boost] [process] Formal review results

Subject: Re: [boost] [process] Formal review results
From: Klemens Morgenstern (klemens.morgenstern_at_[hidden])
Date: 2016-11-09 17:34:56

Am 09.11.2016 um 23:26 schrieb Gavin Lambert:
> On 10/11/2016 09:00, Klemens Morgenstern wrote:
>> That did however allow one additional feature: with the pipe
>> automatically closing, you can now use a part of the asio stuff with
>> bp::spawn.
>>
>> asio::io_service ios;
>> std::future<std::string> fut;
>> bp::spawn("foo", std_out > fut, ios);
>>
>> Not sure this is the smartest thing to do, but it could make sense for
>> some simple applications.
>
> That's quite nice, actually -- a large number of applications would 
> just want to pull the complete output from a process, either with no 
> input or with completely provided input.  It's probably less common to 
> need to hold an interactive conversation, so having a nice quick 
> syntax that hides the stream/pipe work internally is a pretty good win.
>
Well the problem is the potential deadlock, since you cannot terminate 
the process if it hangs. But that's a risk conciously taken if you don't 
store the handle. Makes sense for some processes though.
> Having said that, is there an inverse of this for providing the 
> complete input?  Presumably std_in < std::string(x) can't work, as 
> this would be confused with a filename.  (And while wrapping it in a 
> future is possible, it'd be a bit silly.)
It's "std_in < asio::buffer(x)", whereby buffer is also pulled into the 
process namespace. And you can also use a future which tells when the 
write is complete:

std::string x;
std::future<void> f;
bp::spawn("foo", std_in < asio::buffer(x) > f);

and yeah, that looks a bit weird, but I couldn't think of a better 
operator for this.
>
> This sort of thing kinda makes me wish that the originally proposed 
> future_stream survived into Boost or the standard. Though you can 
> simulate one with a composite future (a future that returns a value 
> and a new future); I have an implementation kicking around somewhere.  
> It's not the prettiest of things nor would it be a simple drop-in 
> though, I think.
If there was some facility like that to use with boost.asio (which has a 
streambuf implementation) you could use it. I could add lazy syntax for 
a popular use-case. That one currently works

asio::streambuf buf;
bp::spawn("foo", std_out > buf);
std::istream(&buf);
//but here I don't know how thread-safe that is, that would be a 
question for boost.asio.