cmUVProcessChain: Add option for external uv_loop_t

Source/cmUVProcessChain.cxx

@@ -38,7 +38,8 @@ struct cmUVProcessChain::InternalData
 
   bool Valid = false;
 
-  cm::uv_loop_ptr Loop;
+  cm::uv_loop_ptr BuiltinLoop;
+  uv_loop_t* Loop;
 
   StreamData InputStreamData;
   StreamData OutputStreamData;
@@ -74,6 +75,19 @@ cmUVProcessChainBuilder& cmUVProcessChainBuilder::AddCommand(
   return *this;
 }
 
+cmUVProcessChainBuilder& cmUVProcessChainBuilder::SetBuiltinLoop()
+{
+  this->Loop = nullptr;
+  return *this;
+}
+
+cmUVProcessChainBuilder& cmUVProcessChainBuilder::SetExternalLoop(
+  uv_loop_t& loop)
+{
+  this->Loop = &loop;
+  return *this;
+}
+
 cmUVProcessChainBuilder& cmUVProcessChainBuilder::SetNoStream(Stream stdio)
 {
   switch (stdio) {
@@ -135,6 +149,11 @@ cmUVProcessChainBuilder& cmUVProcessChainBuilder::SetWorkingDirectory(
   return *this;
 }
 
+uv_loop_t* cmUVProcessChainBuilder::GetLoop() const
+{
+  return this->Loop;
+}
+
 cmUVProcessChain cmUVProcessChainBuilder::Start() const
 {
   cmUVProcessChain chain;
@@ -158,6 +177,13 @@ bool cmUVProcessChain::InternalData::Prepare(
 {
   this->Builder = builder;
 
+  if (this->Builder->Loop) {
+    this->Loop = this->Builder->Loop;
+  } else {
+    this->BuiltinLoop.init();
+    this->Loop = this->BuiltinLoop;
+  }
+
   auto const& input =
     this->Builder->Stdio[cmUVProcessChainBuilder::Stream_INPUT];
   auto& inputData = this->InputStreamData;
@@ -353,7 +379,6 @@ void cmUVProcessChain::InternalData::Finish()
 cmUVProcessChain::cmUVProcessChain()
   : Data(cm::make_unique<InternalData>())
 {
-  this->Data->Loop.init();
 }
 
 cmUVProcessChain::cmUVProcessChain(cmUVProcessChain&& other) noexcept

Source/cmUVProcessChain.h

@@ -30,12 +30,16 @@ public:
 
   cmUVProcessChainBuilder& AddCommand(
     const std::vector<std::string>& arguments);
+  cmUVProcessChainBuilder& SetBuiltinLoop();
+  cmUVProcessChainBuilder& SetExternalLoop(uv_loop_t& loop);
   cmUVProcessChainBuilder& SetNoStream(Stream stdio);
   cmUVProcessChainBuilder& SetBuiltinStream(Stream stdio);
   cmUVProcessChainBuilder& SetMergedBuiltinStreams();
   cmUVProcessChainBuilder& SetExternalStream(Stream stdio, int fd);
   cmUVProcessChainBuilder& SetWorkingDirectory(std::string dir);
 
+  uv_loop_t* GetLoop() const;
+
   cmUVProcessChain Start() const;
 
 private:
@@ -63,6 +67,7 @@ private:
   std::vector<ProcessConfiguration> Processes;
   std::string WorkingDirectory;
   bool MergedBuiltinStreams = false;
+  uv_loop_t* Loop = nullptr;
 };
 
 class cmUVProcessChain

Tests/CMakeLib/testUVProcessChain.cxx

@@ -297,7 +297,12 @@ bool testUVProcessChainBuiltin(const char* helperCommand)
     .AddCommand({ helperCommand, "capitalize" })
     .AddCommand({ helperCommand, "dedup" })
     .SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
-    .SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR);
+    .SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR)
+    .SetBuiltinLoop();
+  if (builder.GetLoop()) {
+    std::cout << "GetLoop() should return null" << std::endl;
+    return false;
+  }
 
   if (!checkExecution(builder, chain)) {
     return false;
@@ -400,6 +405,10 @@ bool testUVProcessChainExternal(const char* helperCommand)
     .AddCommand({ helperCommand, "dedup" })
     .SetExternalStream(cmUVProcessChainBuilder::Stream_OUTPUT, outputPipe[1])
     .SetExternalStream(cmUVProcessChainBuilder::Stream_ERROR, errorPipe[1]);
+  if (builder.GetLoop()) {
+    std::cout << "GetLoop() should return null" << std::endl;
+    return false;
+  }
 
   if (!checkExecution(builder, chain)) {
     return false;
@@ -668,6 +677,43 @@ bool testUVProcessChainWait0(const char* helperCommand)
   return true;
 }
 
+bool testUVProcessChainExternalLoop(const char* helperCommand)
+{
+  cm::uv_loop_ptr loop;
+  loop.init();
+
+  cmUVProcessChainBuilder builder;
+  builder.AddCommand({ helperCommand, "echo" })
+    .SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
+    .SetExternalLoop(*loop);
+  if (builder.GetLoop() != loop) {
+    std::cout << "GetLoop() should return external loop" << std::endl;
+    return false;
+  }
+
+  auto chain = builder.Start();
+
+  if (&chain.GetLoop() != loop) {
+    std::cout << "GetLoop() should return external loop" << std::endl;
+    return false;
+  }
+
+  if (!chain.Wait()) {
+    std::cout << "Wait() timed out" << std::endl;
+    return false;
+  }
+
+  cmUVPipeIStream stream(chain.GetLoop(), chain.OutputStream());
+  std::string output = getInput(stream);
+  if (output != "HELLO world!") {
+    std::cout << "Output was \"" << output << "\", expected \"HELLO world!\""
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
 int testUVProcessChain(int argc, char** const argv)
 {
   if (argc < 2) {
@@ -720,5 +766,10 @@ int testUVProcessChain(int argc, char** const argv)
     return -1;
   }
 
+  if (!testUVProcessChainExternalLoop(argv[1])) {
+    std::cout << "While executing testUVProcessChainExternalLoop().\n";
+    return -1;
+  }
+
   return 0;
 }