Merge pull request #6736 from BOINC/dpa_task_exit

Client: use 'abort' rather than 'quit' when appropriate

Author: AenBleidd

client/app.cpp

@@ -209,7 +209,7 @@ int ACTIVE_TASK::preempt(PREEMPT_TYPE preempt_type, int reason) {
                 result->name
             );
         }
-        return request_exit();
+        return request_quit();
     } else {
         if (show_msg) {
             msg_printf(result->project, MSG_INFO,

client/app.h

@@ -238,33 +238,43 @@ struct ACTIVE_TASK {
 
     // Termination stuff.
     // Terminology:
-    // "kill": forcibly kill the main process and all its descendants.
-    // "request exit": send a request-exit message, and enumerate descendants.
+    // "kill" means kill the main process and all its descendants,
+    //      with SIGKILL on Unix or TerminateProcess on Win
+    // "request_quit": send a quit message, and enumerate descendants.
     //      If after 15 secs any processes remain, kill them
+    //      Use this if the job will be restarted in the future.
     //      called from:
     //          task preemption
-    //          project detach or reset
+    //          client exit
     //      implementation:
     //          sends msg, sets quit_time, state QUIT_PENDING;
     //              get list of descendants
     //          normal exit handled in handle_premature_exit()
     //          timeout handled in ACTIVE_TASK_SET::poll()
-    // "abort_task": like request exit,
-    //      but the app is supposed to write a stack trace to stderr
-    //      called from: rsc exceeded; got ack of running task;
+    // "request_abort": like request quit,
+    //      but send an abort message rather than quit.
+    //      Use this if the job won't be restarted.
+    //      called from:
+    //          project detach or reset
+    //          rsc limit exceeded
+    //          abort request from server
     //          intermediate upload failure
     //          client exiting w/ abort_jobs_on_exit set
+    //      If it gets this, the BOINC API library
+    //      tries to write the call stack to stderr
+    //      so you can e.g. see where an infinite loop happened
     //
-    int request_exit();
+    int request_quit();
     int request_abort();
     int kill_running_task(bool will_restart);
-        // Kill process and subsidiary processes forcibly.
-        // Unix: send a SIGKILL signal, Windows: TerminateProcess()
+        // Kill process and subsidiary processes.
     int kill_subsidiary_processes();
         // kill subsidiary processes of a job
         // whose main process has already exited
     int abort_task(int exit_status, const char*);
         // can be called whether or not process exists
+        // if process exists, request_abort()
+        // else just mark task as aborted
 
     // is the GPU task running or suspended (due to CPU throttling)
     //
@@ -283,8 +293,8 @@ struct ACTIVE_TASK {
         // return true if this task has exited
 
     int suspend();
-        // tell a process to stop executing (but stay in mem)
-        // Done by sending it a <suspend> message
+        // sending process a <suspend> message;
+        // tells it to stop executing but stay in mem
     int unsuspend(int reason=0);
         // Undo a suspend: send a <resume> message
     int preempt(PREEMPT_TYPE preempt_type, int reason=0);
@@ -338,9 +348,9 @@ class ACTIVE_TASK_SET {
     void suspend_all(int reason);
     void unsuspend_all(int reason=0);
     bool is_task_executing();
-    void request_tasks_exit(PROJECT* p=0);
-    int wait_for_exit(double, PROJECT* p=0);
-    int exit_tasks(PROJECT* p=0);
+    void request_tasks_exit(bool will_restart, PROJECT* p);
+    int wait_for_exit(double, PROJECT* p);
+    int exit_tasks(bool will_restart, PROJECT* p);
     void kill_tasks(PROJECT* p=0);
     int abort_project(PROJECT*);
     void get_msgs();

client/app_control.cpp

@@ -199,7 +199,7 @@ static void print_descendants(int pid, const vector<int>& desc, const char* wher
 
 // Send a quit message, start timer, get descendants
 //
-int ACTIVE_TASK::request_exit() {
+int ACTIVE_TASK::request_quit() {
     if (app_client_shm.shm) {
         process_control_queue.msg_queue_send(
             "<quit/>",
@@ -1086,18 +1086,21 @@ void ACTIVE_TASK_SET::request_reread_app_info() {
 }
 
 
-// send quit message to all tasks in the project
+// send quit or abort message to all tasks in the project
 // (or all tasks, if proj is NULL).
 // If they don't exit in QUIT_TIMEOUT seconds,
 // send them a kill signal and wait up to 5 more seconds to exit.
 // This is called when the client exits,
 // or when a project is detached or reset
 //
-int ACTIVE_TASK_SET::exit_tasks(PROJECT* proj) {
+int ACTIVE_TASK_SET::exit_tasks(bool will_restart, PROJECT* proj) {
     if (log_flags.task_debug) {
-        msg_printf(NULL, MSG_INFO, "[task_debug] requesting tasks to exit");
+        msg_printf(NULL, MSG_INFO,
+            "[task_debug] requesting tasks to %s",
+            will_restart ? "quit" : "abort"
+        );
     }
-    request_tasks_exit(proj);
+    request_tasks_exit(will_restart, proj);
 
     // Wait for tasks to exit normally; if they don't then kill them
     //
@@ -1137,6 +1140,7 @@ int ACTIVE_TASK_SET::exit_tasks(PROJECT* proj) {
 // Wait up to wait_time seconds for processes to exit
 // If proj is zero, wait for all processes, else that project's
 // NOTE: it's bad form to sleep, but it would be complex to avoid it here
+// Return 0 if they all exit.
 //
 int ACTIVE_TASK_SET::wait_for_exit(double wait_time, PROJECT* proj) {
     bool all_exited;
@@ -1166,7 +1170,7 @@ int ACTIVE_TASK_SET::abort_project(PROJECT* project) {
     vector<ACTIVE_TASK*>::iterator task_iter;
     ACTIVE_TASK* atp;
 
-    exit_tasks(project);
+    exit_tasks(false, project);
     task_iter = active_tasks.begin();
     while (task_iter != active_tasks.end()) {
         atp = *task_iter;
@@ -1301,18 +1305,22 @@ bool ACTIVE_TASK_SET::is_task_executing() {
     return false;
 }
 
-// Send quit message to all app processes
+// Send quit or abort message to all app processes
 // This is called when the client exits,
 // or when a project is detached or reset
 //
-void ACTIVE_TASK_SET::request_tasks_exit(PROJECT* proj) {
+void ACTIVE_TASK_SET::request_tasks_exit(bool will_restart, PROJECT* proj) {
     unsigned int i;
     ACTIVE_TASK *atp;
     for (i=0; i<active_tasks.size(); i++) {
         atp = active_tasks[i];
         if (proj && atp->wup->project != proj) continue;
         if (!atp->process_exists()) continue;
-        atp->request_exit();
+        if (will_restart) {
+            atp->request_quit();
+        } else {
+            atp->request_abort();
+        }
     }
 }
 

client/client_state.cpp

@@ -2355,7 +2355,7 @@ int CLIENT_STATE::quit_activities() {
     // Do this last because it could take a long time,
     // and the OS might kill us in the middle
     //
-    int retval = active_tasks.exit_tasks();
+    int retval = active_tasks.exit_tasks(true, NULL);
     if (retval) {
         msg_printf(NULL, MSG_INTERNAL_ERROR,
             "Couldn't exit tasks: %s", boincerror(retval)

client/sim_util.cpp

@@ -114,8 +114,8 @@ int ACTIVE_TASK::suspend() {
     return 0;
 }
 
-int ACTIVE_TASK::request_exit() {
-    set_task_state(PROCESS_UNINITIALIZED, "request_exit");
+int ACTIVE_TASK::request_quit() {
+    set_task_state(PROCESS_UNINITIALIZED, "request_quit");
     return 0;
 }
 

lib/util.cpp

@@ -816,6 +816,10 @@ int DOCKER_CONN::parse_image_name(string line, string &name) {
 // CONTAINER ID  IMAGE                                      COMMAND               CREATED        STATUS                   PORTS       NAMES
 // 6d4877e0d071  localhost/boinc__app_test__test_wu:latest  /bin/sh -c ./work...  43 hours ago   Exited (0) 21 hours ago              boinc__app_test__test_result
 //
+// if running, looks like
+// CONTAINER ID  IMAGE                       COMMAND       CREATED        STATUS        PORTS       NAMES
+// bf4ce6e19182  localhost/criu_test:latest  ./counter.sh  9 seconds ago  Up 9 seconds              competent_ishizaka
+
 int DOCKER_CONN::parse_container_name(string line, string &name) {
     char buf[1024];
     strcpy(buf, line.c_str());