Automatically spawn python child process from provider C++ code

BUILD

@@ -62,9 +62,8 @@ cc_binary(
     name = "provider",
     srcs = ["main.cpp"],
     defines = ["PROVIDER=1"] + local_defines,                    
-    deps = [
-        ":src_files",
-    ],
+    deps = [":src_files"],
+    data = ["sorting_python/sorting.py"]
 )
 
 cc_binary(
@@ -74,6 +73,11 @@ cc_binary(
     deps = [":src_files"],
 )
 
+py_binary(
+    name = "sorting",
+    srcs = ["sorting_python/sorting.py"],
+)
+
 ################################# tests BUILD target #################################
 
 cc_test(

include/IPC/zmq_receiver.h

@@ -13,6 +13,7 @@ class ZMQReceiver {
   public:
     ZMQReceiver();
     std::string receive();
+    unsigned int getPort() const;
 };
 
 #endif // _ZMQ_RECEIVER_H_

include/IPC/zmq_sender.h

@@ -13,6 +13,7 @@ class ZMQSender {
   public:
     ZMQSender();
     void send(const std::string& message);
+    unsigned int getPort() const;
 };
 
 #endif // _ZMQ_SENDER_H_

sorting_python/sorting.py

@@ -1,8 +1,9 @@
 import zmq
+import sys
 
 # Set up the context and responder socket
-port_rec = int(input("Enter the ZMQ sender port number: "))
-port_send = int(input("Enter the ZMQ receiver port number: "))
+port_rec = int(sys.argv[1])
+port_send = int(sys.argv[2])
 
 context = zmq.Context()
 responder = context.socket(zmq.REP)

src/IPC/zmq_receiver.cpp

@@ -19,3 +19,7 @@ std::string ZMQReceiver::receive() {
 
     return zmq_msg.to_string();
 }
+
+unsigned int ZMQReceiver::getPort() const {
+    return port;
+}

src/IPC/zmq_sender.cpp

@@ -14,4 +14,8 @@ void ZMQSender::send(const std::string& message) {
 
     zmq::message_t reply;
     socket.recv(reply, zmq::recv_flags::none);
-}
+}
+
+unsigned int ZMQSender::getPort() const {
+    return port;
+}

src/Peers/provider.cpp

@@ -7,6 +7,7 @@
 #include "../../include/utility.h"
 
 #include <algorithm>
+#include <boost/process.hpp>
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
@@ -78,10 +79,32 @@ void Provider::listen() {
             server->closeConn();
         }
 
-        if (task->getLeaderUuid() == uuid) {
-            leaderHandleTaskRequest(requesterIpAddr);
-        } else {
-            followerHandleTaskRequest();
+        try {
+            // Spin up python script child process
+            const char* python_env = std::getenv("PYTHON_INTERPRETER");
+            std::string python_interpreter = python_env ? python_env : "/usr/bin/python3";
+            std::string script_path = "sorting_python/sorting.py";
+            std::vector<std::string> args{
+                std::to_string(zmq_sender.getPort()),
+                std::to_string(zmq_receiver.getPort())};
+            boost::process::child python_script(python_interpreter, script_path, args);
+
+            // Process P2P communication
+            if (task->getLeaderUuid() == uuid) {
+                leaderHandleTaskRequest(requesterIpAddr);
+            } else {
+                followerHandleTaskRequest();
+            }
+
+            // Wait for python script to terminate
+            python_script.wait();
+
+            int exit_code = python_script.exit_code();
+            if (exit_code != 0) {
+                std::cout << "Error: Python child process exited with code: " << exit_code << std::endl;
+            }
+        } catch (const std::exception& e) {
+            std::cerr << "Exception: " << e.what() << std::endl;
         }
     }
 }