update README on abort_parallel_transfers

Author: d-w-moore

README.md

@@ -320,17 +320,43 @@ transfer:
 ```python
 from irods.parallel import abort_parallel_transfers
 
-def handler(*arguments):
+def handler(signal, _)
     abort_parallel_transfers()   
+    os._exit(128 + signal)
 
-signal(SIGINT,handler)
+signal(SIGTERM,handler)
 
 try:
     # a multi-1247 put or get can leave non-daemon threads running if not treated with care.
     session.data_objects.put( ...) 
 except KeyboardInterrupt:
     abort_parallel_transfers()   
-```
+    printf('Due to a SIGINT or Control-C, the put failed.')
+    # Raise again if we wish to exit the application.
+    raise
+except RuntimeError:
+    printf('The put failed.')
+# ...
+```
+
+Note that if had we intercepted SIGINT by assigning it, also, a non-default
+handler, we would have avoided the need to handle the `KeyboardInterrupt`
+inline.
+
+(Internally, of course, the PRC must handle all eventualities, including
+`KeyboardInterrupt`, by closing down the current foreground transfer.
+Otherwise we would risk some non-daemon threads not finishing, and this
+potentially risks holding
+up the main program from eventually performing an orderly exit.)
+
+If a signal handler calls abort_parallel_transfers() but does not call
+`os._exit` after doing so, a parallel `put` or `get` can raise a `RuntimeError`
+to indicate the failed transfer.
+
+In general it is better (for simpler applications wanting to gracefully handle
+interrupted lengthy data transfers to/from iRODS data objects) to anticipate
+control-C by handling both `KeyboardInterrupt` and `RuntimeError`, as shown
+above.
 
 Progress bars
 -------------

irods/parallel.py

@@ -659,14 +659,11 @@ def io_main(session, Data, opr_, fname, R="", **kwopt):
 
     if Operation.isNonBlocking():
 
-#       if queueLength > 0:
         (futures, mgr, chunk_notify_queue) = retval
-#       else:
-#           futures = retval
-            # TODO: investigate: Huh? Why were we zeroing out total_bytes when there is no progress queue? 
-            #chunk_notify_queue = total_bytes = None
 
+        # For convenience, this information can help determine which data object mgr is tracking.
         transfer_managers[mgr] = Data.path
+
         paths_active[Data.path] = async_notify = AsyncNotify(
             futures,  # individual futures, one per transfer thread
             progress_Queue=chunk_notify_queue,  # for notifying the progress indicator thread