Skip to content

std: Support consuming a Process without waiting #14551

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 16, 2014

Conversation

alexcrichton
Copy link
Member

Forking off a child which survives the parent is often a useful task, and is
currently not possible because the Process type will invoke wait() in its
destructor in order to prevent leaking resources. This function adds a new safe
method, daemonize, which can be used to consume an instance of Process which
will then not call wait in the destructor.

This new method is clearly documented as a leak of resources, but it must be
forcibly opted in to.

Closes #14467


/// Forgets this process, allowing it to outlive the parent
///
/// This function will forcefully prevent calling `wait()` on the child
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

What makes it forceful?

@lilyball
Copy link
Contributor

Do we actually want to leave stdin/stdout/stderr/extra_io open? I assumed we'd just want to avoid calling wait().

Also, this doesn't really daemonize the process. It just allows the child to outlive the Process object.

@lilyball
Copy link
Contributor

To clarify, daemonization is typically assumed to involve things like ignoring SIGHUP, and perhaps adopting a new process group.

@alexcrichton
Copy link
Member Author

This doesn't leave the I/O handles open, the function here consumes the type and the drop glue will take over after we canceled our own destructor, closing all the handles.

I suppose I use the term daemon for any long-running process, so I'm not too familiar with any specific connotations it has. Do you have a suggestion for an alternate name to use? The name detach was brought up as partially in conflict with the detach option on Command, so I was hoping to avoid that name.

@lilyball
Copy link
Contributor

Ah, you're right, they'll close automatically. I was fooled by the fact that the Drop impl closes them explicitly, but it's doing that because it needs that to happen before wait().

How about orphan()? It's giving away its child instead of sticking around to take care of it ;)

@alexcrichton
Copy link
Member Author

According to wikipedia, "a daemon is a computer program that runs as a background process, rather than being under the direct control of an interactive user", which sounds like what this is doing. What do others think about the name daemonize?

@lilyball
Copy link
Contributor

daemon() is a function that detaches from the controlling terminal. Notably, it forks and gives the child a new process group. Basically, daemonizing is what Command::detached() does to the new child. The function you're adding does not muck with process groups, and it doesn't muck with SIGHUP (which is the other thing daemonizing usually tweaks).

@lilyball
Copy link
Contributor

Perhaps Command::detached() should be renamed to Command::daemonized() and then your new function can be called detach().

@brson
Copy link
Contributor

brson commented Jun 5, 2014

Regardless of the definition, I feel that 'daemonize' is fairly jargony (and clearly open to interpretation).

@alexcrichton
Copy link
Member Author

Pushed with a renaming of the method to forget which may more accurately reflect what exactly it's doing (only forgetting to collect the status of the process).

@alexcrichton
Copy link
Member Author

ping r?

Forking off a child which survives the parent is often a useful task, and is
currently not possible because the Process type will invoke `wait()` in its
destructor in order to prevent leaking resources. This function adds a new safe
method, `forget`, which can be used to consume an instance of `Process` which
will then not call `wait` in the destructor.

This new method is clearly documented as a leak of resources, but it must be
forcibly opted in to.

Closes rust-lang#14467
bors added a commit that referenced this pull request Jun 16, 2014
Forking off a child which survives the parent is often a useful task, and is
currently not possible because the Process type will invoke `wait()` in its
destructor in order to prevent leaking resources. This function adds a new safe
method, `daemonize`, which can be used to consume an instance of `Process` which
will then not call `wait` in the destructor.

This new method is clearly documented as a leak of resources, but it must be
forcibly opted in to.

Closes #14467
@bors bors closed this Jun 16, 2014
@bors bors merged commit 2fe9264 into rust-lang:master Jun 16, 2014
@alexcrichton alexcrichton deleted the issue-14467 branch June 17, 2014 02:03
bors added a commit to rust-lang-ci/rust that referenced this pull request Jun 5, 2023
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Process should support the child outliving the parent
4 participants