You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by la...@apache.org on 2024/10/21 19:10:41 UTC
(airavata) 02/03: included error outputs and enhanced agent log messages
This is an automated email from the ASF dual-hosted git repository.
lahirujayathilake pushed a commit to branch agent-framewok-refactoring
in repository https://gitbox.apache.org/repos/asf/airavata.git
commit ee9c67cdc0f62fa2566565e47587faa4340960c5
Author: lahiruj <la...@gmail.com>
AuthorDate: Fri Oct 18 18:32:48 2024 -0400
included error outputs and enhanced agent log messages
---
modules/agent-framework/airavata-agent/agent.go | 93 +++++++++++-----------
.../v1l4/jupyterlab/labconfig/airavata_magics.py | 20 ++++-
.../jupyter/deployments/i-guide/agent/kernel.py | 19 +++--
.../jupyterlab/labconfig/airavata_magics.py | 20 ++++-
.../airavata-agent/jupyter/kernel.py | 19 +++--
.../jupyter/labconfig/airavata_magics.py | 20 ++++-
6 files changed, 128 insertions(+), 63 deletions(-)
diff --git a/modules/agent-framework/airavata-agent/agent.go b/modules/agent-framework/airavata-agent/agent.go
index 1fae63950a..6e89469fd2 100644
--- a/modules/agent-framework/airavata-agent/agent.go
+++ b/modules/agent-framework/airavata-agent/agent.go
@@ -56,21 +56,21 @@ func main() {
stdout, err := cmd.StdoutPipe()
if err != nil {
- fmt.Println("Error creating StdoutPipe:", err)
+ fmt.Println("[agent.go] Error creating StdoutPipe:", err)
return
}
// Get stderr pipe
stderr, err := cmd.StderrPipe()
if err != nil {
- fmt.Println("Error creating StderrPipe:", err)
+ fmt.Println("[agent.go] Error creating StderrPipe:", err)
return
}
- log.Printf("Starting command for execution")
+ log.Printf("[agent.go] Starting command for execution")
// Start the command
if err := cmd.Start(); err != nil {
- fmt.Println("Error starting command:", err)
+ fmt.Println("[agent.go] Error starting command:", err)
return
}
@@ -81,24 +81,24 @@ func main() {
// Stream stdout
go func() {
for stdoutScanner.Scan() {
- fmt.Printf("stdout: %s\n", stdoutScanner.Text())
+ fmt.Printf("[agent.go] stdout: %s\n", stdoutScanner.Text())
}
}()
// Stream stderr
go func() {
for stderrScanner.Scan() {
- fmt.Printf("stderr: %s\n", stderrScanner.Text())
+ fmt.Printf("[agent.go] stderr: %s\n", stderrScanner.Text())
}
}()
// Wait for the command to finish
if err := cmd.Wait(); err != nil {
- fmt.Println("Error waiting for command:", err)
+ fmt.Println("[agent.go] Error waiting for command:", err)
return
}
- fmt.Println("Command finished")
+ fmt.Println("[agent.go] Command finished")
}()
go func() {
@@ -109,17 +109,17 @@ func main() {
return
}
if err != nil {
- log.Fatalf("Failed to receive a message : %v", err)
+ log.Fatalf("[agent.go] Failed to receive a message : %v", err)
}
- log.Printf("Received message %s", in.Message)
+ log.Printf("[agent.go] Received message %s", in.Message)
switch x := in.GetMessage().(type) {
case *protos.ServerMessage_CommandExecutionRequest:
- log.Printf("Recived a command execution request")
+ log.Printf("[agent.go] Recived a command execution request")
executionId := x.CommandExecutionRequest.ExecutionId
execArgs := x.CommandExecutionRequest.Arguments
- log.Printf("Execution id %s", executionId)
+ log.Printf("[agent.go] Execution id %s", executionId)
cmd := exec.Command(execArgs[0], execArgs[1:]...)
- log.Printf("Completed execution with the id %s", executionId)
+ log.Printf("[agent.go] Completed execution with the id %s", executionId)
stdout, err := cmd.Output()
if err != nil {
log.Fatalf(err.Error())
@@ -127,60 +127,60 @@ func main() {
}
stdoutString := string(stdout)
- log.Printf("Execution output is %s", stdoutString)
+ log.Printf("[agent.go] Execution output is %s", stdoutString)
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_CommandExecutionResponse{
CommandExecutionResponse: &protos.CommandExecutionResponse{ExecutionId: executionId, ResponseString: stdoutString}}}); err != nil {
- log.Printf("Failed to send execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send execution result to server: %v", err)
}
case *protos.ServerMessage_JupyterExecutionRequest:
- log.Printf("Recived a jupyter execution request")
+ log.Printf("[agent.go] Recived a jupyter execution request")
executionId := x.JupyterExecutionRequest.ExecutionId
sessionId := x.JupyterExecutionRequest.SessionId
code := x.JupyterExecutionRequest.Code
- log.Printf("Execution ID: %s, Session ID: %s, Code: %s", executionId, sessionId, code)
+ log.Printf("[agent.go] Execution ID: %s, Session ID: %s, Code: %s", executionId, sessionId, code)
url := "http://127.0.0.1:15000/start"
client := &http.Client{}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
- log.Printf("Failed to create the request start jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to create the request start jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
- log.Printf("Sending the jupyter execution result to server...")
+ log.Printf("[agent.go] Sending the jupyter kernel start request to server...")
resp, err := client.Do(req)
if err != nil {
- log.Printf("Failed to send the request start jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to send the request start jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
- log.Printf("Successfully sent the jupyter execution result to server")
+ log.Printf("[agent.go] Successfully sent the jupyter kernel start request to server")
defer func() {
err := resp.Body.Close()
if err != nil {
- log.Printf("Failed to close the response body for kernel start: %v", err)
+ log.Printf("[agent.go] Failed to close the response body for kernel start: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
@@ -189,45 +189,46 @@ func main() {
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
- log.Printf("Failed to read response for start jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to read response for start jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
- log.Printf("Starting to marshal JSON data...")
+ log.Printf("[agent.go] Starting to marshal execution request JSON data...")
url = "http://127.0.0.1:15000/execute"
data := map[string]string{
- "code": code,
+ "code": code,
+ "executionId": executionId,
}
jsonData, err := json.Marshal(data)
if err != nil {
- log.Fatalf("Failed to marshal JSON: %v", err)
+ log.Fatalf("[agent.go] Failed to marshal JSON: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
- log.Printf("Successful marshaling the JSON data")
+ log.Printf("[agent.go] Successful marshaling the JSON data")
req, err = http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
- log.Printf("Failed to create the request run jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to create the request run jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
@@ -238,63 +239,63 @@ func main() {
resp, err = client.Do(req)
if err != nil {
- log.Printf("Failed to send the request run jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to send the request run jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
defer func() {
- log.Printf("Closing the response...")
+ log.Printf("[agent.go] Closing the response...")
err := resp.Body.Close()
if err != nil {
- log.Printf("Failed to close the response body for kernel execution: %v", err)
+ log.Printf("[agent.go] Failed to close the response body for kernel execution: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
}()
- log.Printf("Sending the jupyter execution result to server...")
+ log.Printf("[agent.go] Sending the jupyter execution " + executionId + "result to server...")
body, err = ioutil.ReadAll(resp.Body)
if err != nil {
- log.Printf("Failed to read response for run jupyter kernel: %v", err)
+ log.Printf("[agent.go] Failed to read response for run jupyter kernel: %v", err)
jupyterResponse := "Failed while running the cell in remote. Please retry"
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
return
}
jupyterResponse := string(body)
- log.Println("Jupyter execution response: " + jupyterResponse)
+ log.Println("[agent.go] Jupyter execution " + executionId + "response: " + jupyterResponse)
if err := stream.Send(&protos.AgentMessage{Message: &protos.AgentMessage_JupyterExecutionResponse{
JupyterExecutionResponse: &protos.JupyterExecutionResponse{ExecutionId: executionId, ResponseString: jupyterResponse, SessionId: sessionId}}}); err != nil {
- log.Printf("Failed to send jupyter execution result to server: %v", err)
+ log.Printf("[agent.go] Failed to send jupyter execution result to server: %v", err)
}
case *protos.ServerMessage_TunnelCreationRequest:
- log.Printf("Received a tunnel creation request")
+ log.Printf("[agent.go] Received a tunnel creation request")
host := x.TunnelCreationRequest.DestinationHost
destPort := x.TunnelCreationRequest.DestinationPort
srcPort := x.TunnelCreationRequest.SourcePort
keyPath := x.TunnelCreationRequest.SshKeyPath
sshUser := x.TunnelCreationRequest.SshUserName
- log.Printf("Tunnel details - Host: %s, DestPort: %s, SrcPort: %s, KeyPath: %s, SSH User: %s", host, destPort, srcPort, keyPath, sshUser)
+ log.Printf("[agent.go] Tunnel details - Host: %s, DestPort: %s, SrcPort: %s, KeyPath: %s, SSH User: %s", host, destPort, srcPort, keyPath, sshUser)
openRemoteTunnel(host, destPort, srcPort, sshUser, keyPath)
}
diff --git a/modules/agent-framework/airavata-agent/jupyter/deployments/cerebrum/v1l4/jupyterlab/labconfig/airavata_magics.py b/modules/agent-framework/airavata-agent/jupyter/deployments/cerebrum/v1l4/jupyterlab/labconfig/airavata_magics.py
index dd629dfd09..b472ba2382 100644
--- a/modules/agent-framework/airavata-agent/jupyter/deployments/cerebrum/v1l4/jupyterlab/labconfig/airavata_magics.py
+++ b/modules/agent-framework/airavata-agent/jupyter/deployments/cerebrum/v1l4/jupyterlab/labconfig/airavata_magics.py
@@ -179,7 +179,25 @@ def run_remote(line, cell):
# print(data_obj['text/plain'])
elif output_type == 'stream':
- print(output.get('text', ''))
+ stream_name = output.get('name', 'stdout')
+ stream_text = output.get('text', '')
+ if stream_name == 'stderr':
+ error_html = f"""
+ <div style="
+ color: #a71d5d;
+ background-color: #fdd;
+ border: 1px solid #a71d5d;
+ padding: 10px;
+ border-radius: 5px;
+ font-family: Consolas, 'Courier New', monospace;
+ white-space: pre-wrap;
+ ">
+ {stream_text}
+ </div>
+ """
+ display(HTML(error_html))
+ else:
+ print(stream_text)
elif output_type == 'error':
ename = output.get('ename', 'Error')
diff --git a/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/agent/kernel.py b/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/agent/kernel.py
index 17dc3ab110..c9bd281479 100644
--- a/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/agent/kernel.py
+++ b/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/agent/kernel.py
@@ -57,10 +57,8 @@ def execute():
while True:
try:
- msg = kc.get_iopub_msg(timeout=1)
- print("------------------")
- print(msg)
- print("-================-")
+ msg = kc.get_iopub_msg(timeout=5)
+
content = msg.get("content", {})
msg_type = msg.get("msg_type", "")
@@ -68,7 +66,7 @@ def execute():
if msg_type == "execute_input":
execution_noticed = True
- # Handle stdout text stream
+ # Handle stdout streams
if msg_type == "stream" and content.get("name") == "stdout":
outputs.append({
"output_type": "stream",
@@ -76,7 +74,15 @@ def execute():
"text": content.get("text", "")
})
- # Capture display data (e.g. plot)
+ # Handle stderr streams
+ if msg_type == "stream" and content.get("name") == "stderr":
+ outputs.append({
+ "output_type": "stream",
+ "name": "stderr",
+ "text": content.get("text", "")
+ })
+
+ # Handle display data (e.g. plots)
if msg_type == "display_data":
outputs.append({
"output_type": "display_data",
@@ -112,7 +118,6 @@ def execute():
return jsonify({'error': "Execution interrupted by user"}), 500
except Exception as e:
print(f"Error while getting Jupyter message: {str(e)}")
- pass
response = {
"outputs": outputs
diff --git a/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/jupyterlab/labconfig/airavata_magics.py b/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/jupyterlab/labconfig/airavata_magics.py
index ec0d653d85..7d286f0ab2 100644
--- a/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/jupyterlab/labconfig/airavata_magics.py
+++ b/modules/agent-framework/airavata-agent/jupyter/deployments/i-guide/jupyterlab/labconfig/airavata_magics.py
@@ -187,7 +187,25 @@ def run_remote(line, cell):
# print(data_obj['text/plain'])
elif output_type == 'stream':
- print(output.get('text', ''))
+ stream_name = output.get('name', 'stdout')
+ stream_text = output.get('text', '')
+ if stream_name == 'stderr':
+ error_html = f"""
+ <div style="
+ color: #a71d5d;
+ background-color: #fdd;
+ border: 1px solid #a71d5d;
+ padding: 10px;
+ border-radius: 5px;
+ font-family: Consolas, 'Courier New', monospace;
+ white-space: pre-wrap;
+ ">
+ {stream_text}
+ </div>
+ """
+ display(HTML(error_html))
+ else:
+ print(stream_text)
elif output_type == 'error':
ename = output.get('ename', 'Error')
diff --git a/modules/agent-framework/airavata-agent/jupyter/kernel.py b/modules/agent-framework/airavata-agent/jupyter/kernel.py
index 17dc3ab110..c9bd281479 100644
--- a/modules/agent-framework/airavata-agent/jupyter/kernel.py
+++ b/modules/agent-framework/airavata-agent/jupyter/kernel.py
@@ -57,10 +57,8 @@ def execute():
while True:
try:
- msg = kc.get_iopub_msg(timeout=1)
- print("------------------")
- print(msg)
- print("-================-")
+ msg = kc.get_iopub_msg(timeout=5)
+
content = msg.get("content", {})
msg_type = msg.get("msg_type", "")
@@ -68,7 +66,7 @@ def execute():
if msg_type == "execute_input":
execution_noticed = True
- # Handle stdout text stream
+ # Handle stdout streams
if msg_type == "stream" and content.get("name") == "stdout":
outputs.append({
"output_type": "stream",
@@ -76,7 +74,15 @@ def execute():
"text": content.get("text", "")
})
- # Capture display data (e.g. plot)
+ # Handle stderr streams
+ if msg_type == "stream" and content.get("name") == "stderr":
+ outputs.append({
+ "output_type": "stream",
+ "name": "stderr",
+ "text": content.get("text", "")
+ })
+
+ # Handle display data (e.g. plots)
if msg_type == "display_data":
outputs.append({
"output_type": "display_data",
@@ -112,7 +118,6 @@ def execute():
return jsonify({'error': "Execution interrupted by user"}), 500
except Exception as e:
print(f"Error while getting Jupyter message: {str(e)}")
- pass
response = {
"outputs": outputs
diff --git a/modules/agent-framework/airavata-agent/jupyter/labconfig/airavata_magics.py b/modules/agent-framework/airavata-agent/jupyter/labconfig/airavata_magics.py
index 322a10adc8..d2b34d5d6a 100644
--- a/modules/agent-framework/airavata-agent/jupyter/labconfig/airavata_magics.py
+++ b/modules/agent-framework/airavata-agent/jupyter/labconfig/airavata_magics.py
@@ -178,7 +178,25 @@ def run_remote(line, cell):
# print(data_obj['text/plain'])
elif output_type == 'stream':
- print(output.get('text', ''))
+ stream_name = output.get('name', 'stdout')
+ stream_text = output.get('text', '')
+ if stream_name == 'stderr':
+ error_html = f"""
+ <div style="
+ color: #a71d5d;
+ background-color: #fdd;
+ border: 1px solid #a71d5d;
+ padding: 10px;
+ border-radius: 5px;
+ font-family: Consolas, 'Courier New', monospace;
+ white-space: pre-wrap;
+ ">
+ {stream_text}
+ </div>
+ """
+ display(HTML(error_html))
+ else:
+ print(stream_text)
elif output_type == 'error':
ename = output.get('ename', 'Error')