Remove use of globals, and add debug logs.

Author: Carreau

enterprise_gateway/services/processproxies/processproxy.py

@@ -399,6 +399,8 @@ def __init__(self, kernel_manager, proxy_config):
         self.ip = None
         self.pid = 0
         self.pgid = 0
+        self.remote_user = None
+        self.remote_pwd = None
 
     @abc.abstractmethod
     async def launch_process(self, kernel_cmd, **kwargs):
@@ -584,14 +586,14 @@ def _get_ssh_client(self, host):
         """
         ssh = None
 
-        global remote_user
-        global remote_pwd
         use_gss = os.getenv("EG_REMOTE_GSS_SSH", None)
         if remote_user is None:
-            remote_pwd = os.getenv("EG_REMOTE_PWD")  # this should use password-less ssh
-            remote_user = os.getenv("EG_REMOTE_USER", getpass.getuser())
+            self.remote_pwd = os.getenv(
+                "EG_REMOTE_PWD"
+            )  # this should use password-less ssh
+            self.remote_user = os.getenv("EG_REMOTE_USER", getpass.getuser())
 
-            if use_gss and (remote_pwd or remote_user):
+            if use_gss and (self.remote_pwd or self.remote_user):
                 warnings.warn(
                     "Both `EG_REMOTE_GSS_SSH` and one of `EG_REMOTE_PWD` or `EG_REMOTE_USER` is set. "
                     "Those options are mutually exclusive, you configuration may be incorrect. "
@@ -603,18 +605,23 @@ def _get_ssh_client(self, host):
             ssh.load_system_host_keys()
             host_ip = gethostbyname(host)
             if use_gss:
+                self.log.debug("Connecting to remote host via GSS.")
                 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                 ssh.connect(host_ip, port=ssh_port, gss_auth=True)
             else:
                 ssh.set_missing_host_key_policy(paramiko.RejectPolicy())
-                if remote_pwd:
+                if self.remote_pwd:
+                    self.log.debug(
+                        "Connecting to remote host with username and password."
+                    )
                     ssh.connect(
                         host_ip,
                         port=ssh_port,
-                        username=remote_user,
-                        password=remote_pwd,
+                        username=self.remote_user,
+                        password=self.remote_pwd,
                     )
                 else:
+                    self.log.debug("Connecting to remote host with ssh key.")
                     ssh.connect(host_ip, port=ssh_port, username=remote_user)
         except Exception as e:
             http_status_code = 500
@@ -1284,12 +1291,23 @@ def _send_listener_request(self, request, shutdown_socket=False):
                         sock.shutdown(SHUT_WR)
                     except Exception as e2:
                         if isinstance(e2, OSError) and e2.errno == errno.ENOTCONN:
-                            pass  # Listener is not connected.  This is probably a follow-on to ECONNREFUSED on connect
+                            # Listener is not connected.  This is probably a follow-on to ECONNREFUSED on connect
+                            self.log.debug(
+                                "ERROR: OSError(ENOTCONN) raised on socket shutdown, "
+                                "listener likely not connected. Cannot send {request}",
+                                request=request,
+                            )
                         else:
                             self.log.warning("Exception occurred attempting to shutdown communication socket to {}:{} "
                                              "for KernelID '{}' (ignored): {}".format(self.comm_ip, self.comm_port,
                                                                                       self.kernel_id, str(e2)))
                 sock.close()
+        else:
+            self.log.debug(
+                "Invalid comm port, not sending request '{}' to comm_port '{}'.",
+                request,
+                self.comm_port,
+            )
 
     def send_signal(self, signum):
         """
@@ -1303,17 +1321,20 @@ def send_signal(self, signum):
         # using anything other than the socket-based signal (via signal_addr) will not work.
 
         if self.comm_port > 0:
-            signal_request = dict()
-            signal_request['signum'] = signum
 
             try:
-                self._send_listener_request(signal_request)
+                self._send_listener_request({"signum": signum})
 
                 if signum > 0:  # Polling (signum == 0) is too frequent
                     self.log.debug("Signal ({}) sent via gateway communication port.".format(signum))
                 return None
             except Exception as e:
-                if isinstance(e, OSError) and e.errno == errno.ECONNREFUSED:  # Return False since there's no process.
+                if (
+                    isinstance(e, OSError) and e.errno == errno.ECONNREFUSED
+                ):  # Return False since there's no process.
+                    self.log.debug(
+                        "ERROR: ECONNREFUSED, no process listening, cannot send signal."
+                    )
                     return False
 
                 self.log.warning("An unexpected exception occurred sending signal ({}) for KernelID '{}': {}"