Codemod: use #include angle brackets in folly and thrift

[folly.git] / folly / Subprocess.h

diff --git a/folly/Subprocess.h b/folly/Subprocess.h
index 74e9fe9b1e13a20890a0b7f2d47886c7406b60f1..e1fed9f7beb6a1ef4c4a28309f7b6a9354047840 100644 (file)
--- a/folly/Subprocess.h
+++ b/folly/Subprocess.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 Facebook, Inc.
+ * Copyright 2014 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -56,7 +56,11 @@
 
 #include <sys/types.h>
 #include <signal.h>
+#if __APPLE__
+#include <sys/wait.h>
+#else
 #include <wait.h>
+#endif
 
 #include <exception>
 #include <vector>
@@ -66,10 +70,10 @@
 #include <boost/operators.hpp>
 #include <boost/noncopyable.hpp>
 
-#include "folly/io/IOBufQueue.h"
-#include "folly/MapUtil.h"
-#include "folly/Portability.h"
-#include "folly/Range.h"
+#include <folly/io/IOBufQueue.h>
+#include <folly/MapUtil.h>
+#include <folly/Portability.h>
+#include <folly/Range.h>
 
 namespace folly {
 
@@ -201,8 +205,7 @@ class Subprocess : private boost::noncopyable {
    public:
     Options()
       : closeOtherFds_(false),
-        usePath_(false),
-        parentDeathSignal_(0) {
+        usePath_(false) {
     }
 
     /**
@@ -261,6 +264,12 @@ class Subprocess : private boost::noncopyable {
      */
     Options& usePath() { usePath_ = true; return *this; }
 
+    /**
+     * Change the child's working directory, after the vfork.
+     */
+    Options& chdir(const std::string& dir) { childDir_ = dir; return *this; }
+
+#if __linux__
     /**
      * Child will receive a signal when the parent exits.
      */
@@ -268,6 +277,7 @@ class Subprocess : private boost::noncopyable {
       parentDeathSignal_ = sig;
       return *this;
     }
+#endif
 
     /**
      * Helpful way to combine Options.
@@ -279,7 +289,10 @@ class Subprocess : private boost::noncopyable {
     FdMap fdActions_;
     bool closeOtherFds_;
     bool usePath_;
-    int parentDeathSignal_;
+    std::string childDir_;  // "" keeps the parent's working directory
+#if __linux__
+    int parentDeathSignal_{0};
+#endif
   };
 
   static Options pipeStdin() { return Options().stdin(PIPE); }
@@ -328,12 +341,15 @@ class Subprocess : private boost::noncopyable {
    * If stdout or stderr is not a pipe, an empty IOBuf queue will be returned
    * for the respective buffer.
    *
-   * Note that communicate() returns when all pipes to/from the child are
-   * closed; the child might stay alive after that, so you must still wait().
+   * Note that communicate() and communicateIOBuf() both return when all
+   * pipes to/from the child are closed; the child might stay alive after
+   * that, so you must still wait().
+   *
+   * communicateIOBuf() uses IOBufQueue for buffering (which has the
+   * advantage that it won't try to allocate all data at once), but it does
+   * store the subprocess's entire output in memory before returning.
    *
-   * communicateIOBuf uses IOBufQueue for buffering (which has the advantage
-   * that it won't try to allocate all data at once).  communicate
-   * uses strings for simplicity.
+   * communicate() uses strings for simplicity.
    */
   std::pair<IOBufQueue, IOBufQueue> communicateIOBuf(
       IOBufQueue input = IOBufQueue());
@@ -376,6 +392,18 @@ class Subprocess : private boost::noncopyable {
   typedef std::function<bool(int, int)> FdCallback;
   void communicate(FdCallback readCallback, FdCallback writeCallback);
 
+  /**
+   * Enable notifications (callbacks) for one pipe to/from child. By default,
+   * all are enabled. Useful for "chatty" communication -- you want to disable
+   * write callbacks until you receive the expected message.
+   */
+  void enableNotifications(int childFd, bool enabled);
+
+  /**
+   * Are notifications for one pipe to/from child enabled?
+   */
+  bool notificationsEnabled(int childFd) const;
+
   /**
    * Return the child's pid, or -1 if the child wasn't successfully spawned
    * or has already been wait()ed upon.
@@ -497,9 +525,11 @@ class Subprocess : private boost::noncopyable {
   // so we're happy with a vector here, even if it means linear erase.
   // sorted by childFd
   struct PipeInfo : private boost::totally_ordered<PipeInfo> {
-    int parentFd;
-    int childFd;
-    int direction;  // one of PIPE_IN / PIPE_OUT
+    int parentFd = -1;
+    int childFd = -1;
+    int direction = PIPE_IN;  // one of PIPE_IN / PIPE_OUT
+    bool enabled = true;
+
     bool operator<(const PipeInfo& other) const {
       return childFd < other.childFd;
     }