Flow custom error messages to client.

This PR also requires [Kernel Gateway PR 284](jupyter-server/kernel_gateway#284)

In absence of that PR, the default message corresponding
to the status code will be returned to the caller.

This PR is essentially preparation to have custom
error messages returned.

Fixes #296
Closes #310

Author: kevin-bates

enterprise_gateway/services/processproxies/conductor.py

@@ -47,8 +47,10 @@ def launch_process(self, kernel_cmd, **kw):
         if env_dict and 'EGO_SERVICE_CREDENTIAL' in env_dict:
             self.rest_credential = env_dict['EGO_SERVICE_CREDENTIAL']
         else:
-            self.log.error("ConductorClusterProcessProxy failed to obtain the Conductor credential.")
-            raise tornado.web.HTTPError(500, "ConductorClusterProcessProxy failed to obtain the Conductor credential.")
+            error_message = "ConductorClusterProcessProxy failed to obtain the Conductor credential."
+            self.log.error(error_message)
+            raise tornado.web.HTTPError(500, reason=error_message)
+
         # dynamically update Spark submit parameters
         self.update_launch_info(kernel_cmd, **kw)
         # Enable stderr PIPE for the run command
@@ -197,10 +199,11 @@ def confirm_remote_startup(self, kernel_cmd, **kw):
                 app_state = self.get_application_state()
 
                 if app_state in ConductorClusterProcessProxy.final_states:
-                    raise tornado.web.HTTPError(500, "KernelID: '{}', ApplicationID: '{}' unexpectedly found in"
-                                                     "state '{}' during kernel startup!".format(self.kernel_id,
-                                                                                                self.application_id,
-                                                                                                app_state))
+                    error_message = "KernelID: '{}', ApplicationID: '{}' unexpectedly found in " \
+                                                     "state '{}' during kernel startup!".\
+                                    format(self.kernel_id, self.application_id, app_state)
+                    self.log.error(error_message)
+                    raise tornado.web.HTTPError(500, reason=error_message)
 
                 self.log.debug("{}: State: '{}', Host: '{}', KernelID: '{}', ApplicationID: '{}'".
                                format(i, app_state, self.assigned_host, self.kernel_id, self.application_id))
@@ -243,7 +246,7 @@ def handle_timeout(self):
             self.kill()
             timeout_message = "KernelID: '{}' launch timeout due to: {}".format(self.kernel_id, reason)
             self.log.error(timeout_message)
-            raise tornado.web.HTTPError(error_http_code, timeout_message)
+            raise tornado.web.HTTPError(error_http_code, reason=timeout_message)
 
     def get_application_id(self, ignore_final_states=False):
         # Return the kernel's application ID if available, otherwise None.  If we're obtaining application_id
@@ -380,7 +383,7 @@ def kill_app_by_driver_id(self, driver_id):
             if self.application_id is None:
                 return None 
             self.log.debug("Driver does not exist, retrieving DriverID with ApplicationID: {}".format(self.application_id))
-            driver_info = get_driver_by_app_id(self.application_id)
+            driver_info = self.get_driver_by_app_id(self.application_id)
             if driver_info:
                 self.driver_id = driver_info['id']
             else:

enterprise_gateway/services/processproxies/distributed.py

@@ -121,4 +121,4 @@ def handle_timeout(self):
             timeout_message = "KernelID: '{}' launch timeout due to: {}".format(self.kernel_id, reason)
             self.log.error(timeout_message)
             self.kill()
-            raise tornado.web.HTTPError(error_http_code, timeout_message)
+            raise tornado.web.HTTPError(error_http_code, reason=timeout_message)

enterprise_gateway/services/processproxies/processproxy.py

@@ -239,7 +239,7 @@ def _get_ssh_client(self, host):
             if e is paramiko.SSHException or paramiko.AuthenticationException:
                 error_message_prefix = "Failed to authenticate SSHClient with password"
                 error_message = error_message_prefix + (" provided" if remote_pwd else "-less SSH")
-                raise tornado.web.HTTPError(403, error_message)
+                raise tornado.web.HTTPError(403, reason=error_message)
             else:
                 raise e
         return ssh
@@ -352,7 +352,7 @@ def _raise_authorization_error(self, kernel_username, differentiator_clause):
                         "Ensure KERNEL_USERNAME is set to an appropriate value and retry the request.". \
             format(kernel_username, differentiator_clause, kernel_clause)
         self.log.error(error_message)
-        raise tornado.web.HTTPError(403, error_message)
+        raise tornado.web.HTTPError(403, reason=error_message)
 
     def _enforce_limits(self, **kw):
         """
@@ -685,9 +685,10 @@ def receive_connection_info(self):
                 if conn:
                     conn.close()
         else:
-            raise tornado.web.HTTPError(500,
-                                        "Unexpected runtime found for KernelID '{}'!  "
-                                        "No response socket exists".format(self.kernel_id))
+            error_message = "Unexpected runtime found for Kernel ID '{}'!  No response socket exists".format(self.kernel_id)
+            self.log.error(error_message)
+            raise tornado.web.HTTPError(500, reason=error_message)
+
         return ready_to_connect
 
     # Do NOT update connect_info with IP and other such artifacts in this method/function.

enterprise_gateway/services/processproxies/yarn.py

@@ -154,10 +154,11 @@ def confirm_remote_startup(self, kernel_cmd, **kw):
                 app_state = self.get_application_state()
 
                 if app_state in YarnClusterProcessProxy.final_states:
-                    raise tornado.web.HTTPError(500, "KernelID: '{}', ApplicationID: '{}' unexpectedly found in"
-                                                     "state '{}' during kernel startup!".format(self.kernel_id,
-                                                                                                self.application_id,
-                                                                                                app_state))
+                    error_message = "KernelID: '{}', ApplicationID: '{}' unexpectedly found in " \
+                                                     "state '{}' during kernel startup!".\
+                                    format(self.kernel_id, self.application_id, app_state)
+                    self.log.error(error_message)
+                    raise tornado.web.HTTPError(500, reason=error_message)
 
                 self.log.debug("{}: State: '{}', Host: '{}', KernelID: '{}', ApplicationID: '{}'".
                                format(i, app_state, self.assigned_host, self.kernel_id, self.application_id))
@@ -199,7 +200,7 @@ def handle_timeout(self):
             self.kill()
             timeout_message = "KernelID: '{}' launch timeout due to: {}".format(self.kernel_id, reason)
             self.log.error(timeout_message)
-            raise tornado.web.HTTPError(error_http_code, timeout_message)
+            raise tornado.web.HTTPError(error_http_code, reason=timeout_message)
 
     def get_application_id(self, ignore_final_states=False):
         # Return the kernel's YARN application ID if available, otherwise None.  If we're obtaining application_id