working version

Author: Avi-Robusta

additional_bash_commands.sh

@@ -1,11 +1,14 @@
 alias get_java_pid='ps aux | grep java | grep -v grep | cut -d" " -f6'
-alias push_jdk='mkdir -p /proc/$(ps aux | grep java | grep -v grep | cut -d" " -f6)/cwd/mnt/robusta;\
-cp -r /app/openjdk /proc/$(ps aux | grep java | grep -v grep | cut -d" " -f6)/cwd/mnt/robusta'
-alias cleanup='rm -r /proc/$(ps aux | grep java | grep -v grep | cut -d" " -f6)/cwd/mnt/robusta'
-alias podns_shell='nsenter -t $(ps aux | grep java | grep -v grep | cut -d" " -f6) -m -p /bin/sh'
+alias push_jdk='mkdir -p /proc/$PID/cwd/mnt/robusta;\
+cp -r /app/openjdk /proc/$PID/cwd/mnt/robusta'
+alias cleanup='rm -r /proc/$PID/cwd/mnt/robusta'
+alias podns_shell='nsenter -t $PID -m -p /bin/sh'
+
+alias push_jdk='mkdir -p /proc/$PID/cwd/mnt/robusta;\
+cp -r /app/openjdk* /proc/$PID/cwd/mnt/robusta'
 
 function nsjdk(){
-	local NSENTER_CMD='nsenter -t $(ps aux | grep java | grep -v grep | cut -d" " -f6) -m -p /mnt/robusta/openjdk/bin/'
+	local NSENTER_CMD='nsenter -t $PID -m -p /mnt/robusta/openjdk/bin/'
 	COMMAND=""
 	if [ "$1" = "jmap" ]; then COMMAND="jmap $2";
 	elif [ "$1" = "jstack" ]; then COMMAND="java-toolkit jstack $2";

dockerfile

@@ -12,9 +12,13 @@ WORKDIR /app/
 RUN /root/.local/bin/poetry install --no-interaction --no-root
 
 COPY src /app/src
+
 RUN /root/.local/bin/poetry install
 RUN cat additional_bash_commands.sh >> ~/.bashrc
-COPY --from=adoptopenjdk/openjdk11-openj9:ppc64le-ubuntu-jdk-11.0.14_9_openj9-0.30.0 /opt/java/openjdk /app/openjdk
+#COPY jdk_11_9 /app/openjdk3
+COPY --from=openjdk:11.0.14-jdk /usr/local/openjdk-11  /app/openjdk
+#COPY --from=adoptopenjdk/openjdk11-openj9:jdk-11.0.14_9_openj9-0.30.0-alpine /opt/java/openjdk  /app/openjdk2
+
 CMD exec /bin/bash -c "trap : TERM INT; sleep infinity & wait"
 
 #run on jenkens

src/java_toolkit/common/utils/processes.py renamed to src/java_toolkit/common/utils/process.py

@@ -15,7 +15,7 @@
     r"\d+:.+:/kubepods\.slice/kubepods-[^/]+\.slice/kubepods-[^/]+-pod([^/]+)\.slice/docker-([0-9a-f]{64})"
 )
 
-ps_regex = re.compile(r"\s*(?P<pid>.*?)\s+(?P<cmd>.*?)\s+(?P<cmd_args>.*?)\n")
+ps_regex = re.compile(r"\s*(?P<pid>.*?)\s+(?P<cmd>.*?)\s+(?P<cmd_args>.*?)$")
 
 app = typer.Typer()
 
@@ -64,16 +64,21 @@ def get_pod_processes(pod_uid: str) -> ProcessList:
             processes.append(Process(pid=pid, exe=proc.exe(), cmdline=proc.cmdline()))
     return ProcessList(processes=processes)
 
+def get_pid_info(pid: int) -> Process:
+    proc = psutil.Process(pid)
+    return Process(pid=pid, exe=proc.exe(), cmdline=proc.cmdline())
+
 def get_ns_processes(pid_in_ns: int, verbose: bool):
-    cmd = "ps -o pid,comm,args | tail -n +2 "
+    cmd = "ps -Ao pid,comm,args | grep -v PID"
     processes = run_cmd_in_proc_namespace(pid_in_ns, cmd, verbose)
     processes = processes.split('\n')
     return_proc_list=[]
-    processes.remove(processes[0]) #title column
     for proc_line in processes:
-        if "tail -n" in proc_line or "ps -o pid,comm,args" in proc_line:
+        if not proc_line:
             continue
         match = ps_regex.match(proc_line)
+        if not match:
+            continue
         pid = int(match.group("pid"))
         exe = match.group("cmd")
         cmdline = match.group("cmd_args")
@@ -82,7 +87,7 @@ def get_ns_processes(pid_in_ns: int, verbose: bool):
         else:
             cmdline = cmdline.split(' ')
         return_proc_list.append(Process(pid=pid, exe=exe, cmdline=cmdline))
-    return return_proc_list
+    return ProcessList(processes=return_proc_list)
 
 
 

src/java_toolkit/common/utils/remote_ns_cmd.py

@@ -5,18 +5,11 @@
 def run_command(cmd: str, verbose: bool):
     if verbose:
         typer.echo(f"Running {cmd}")
-    proc = subprocess.Popen(
-        cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.STDOUT
-    )
-    (output, err) = proc.communicate()
-
-    proc.stdout.close()
-    return_code = proc.wait()
-    if return_code:
-        raise subprocess.CalledProcessError(return_code, cmd)
+    output = subprocess.check_output(
+        cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.STDOUT)
     if verbose:
-        typer.echo(output)
-    return output, err
+        typer.echo(f"output recieved: \n{output.decode()}")
+    return output.decode()
 
 def run_cmd_in_proc_namespace(pid, command_to_run, verbose):
     NSENTER_CMD = "nsenter -t {} -p -m {}"

src/java_toolkit/common/utils/tmp_mount.py

@@ -1,5 +1,5 @@
 from .remote_ns_cmd import run_command
-from os.path import join, basename
+from os import path
 
 class TmpRemotePodMounter(object):
     remote_mnt_path =""
@@ -9,13 +9,13 @@ class TmpRemotePodMounter(object):
     MKDIR_POD_CMD="mkdir -p {}"
     RMDIR_POD_CMD="rm -R {}"
     COPY_CMD="cp -R {} {}"
-    ROOT_PROC_NS="/proc/{}/cwd",
+    ROOT_PROC_NS="/proc/{}/cwd{}"
 
     def __init__(self, pid: str, src_dir: str, local_mnt_path: str, verbose: bool):
         self.verbose = verbose
         self.src_dir = src_dir
         self.local_mnt_path = local_mnt_path
-        self.remote_mnt_path = join(self.ROOT_PROC_NS.format(pid), local_mnt_path)
+        self.remote_mnt_path = self.ROOT_PROC_NS.format(pid,local_mnt_path)
 
     def __enter__(self):
         mkdir_cmd = self.MKDIR_POD_CMD.format(self.remote_mnt_path)
@@ -25,7 +25,7 @@ def __enter__(self):
         return self
 
     def get_mounted_jdk_dir(self):
-            return join(self.local_mnt_path, basename(self.src_dir) )
+            return path.join(self.local_mnt_path, path.basename(self.src_dir) )
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         rm_dir_cmd = self.RMDIR_POD_CMD.format(self.remote_mnt_path)

src/java_toolkit/configs.json

@@ -1,5 +1,18 @@
+##### PATHS ####
+"""
+    JDK_PATH is the path our docker image stores the jdk. if you would like to change this you also will have to update
+    your dockerfile. For multiple jdk versions you will need a different JDK_PATH for each one.
+
+    LOCAL_MOUNT_PATH is the path the jdk will be temporary saved on to your pod
+"""
 JDK_PATH= "/app/openjdk"
 LOCAL_MOUNT_PATH= "/mnt/robusta"
-JDK_NAME= "openjdk"
-JMAP_CMD= "{}/bin/jmap -J-Xshareclasses:nonfatal -histo:live {}"
-JSTACK_CMD= "{}/bin/jstack -J-Xshareclasses:nonfatal -l {}"
+
+##### JDK COMMANDS####
+"""
+    they need the variable {jdk_path} in the command
+    if it requires a pid add it in the {pid} field
+    any flags the command needs add to the command itself
+"""
+JMAP_CMD= "{jdk_path}/bin/jmap -histo:live {pid}"
+JSTACK_CMD= "{jdk_path}/bin/jstack -l {pid}"

src/java_toolkit/configs.py

@@ -1,34 +1,57 @@
 #!/usr/local/bin/python3
 import subprocess
 import typer
-from .utils.process import get_pod_processes, get_ns_processes
-from .utils.remote_ns_cmd import run_cmd_in_proc_namespace
-from .utils.tmp_mount import TmpRemotePodMounter
+from .common.utils.process import *
+from .common.utils.remote_ns_cmd import run_cmd_in_proc_namespace
+from .common.utils.tmp_mount import TmpRemotePodMounter
 from .configs import *
-from os.path import join
 
 app = typer.Typer()
 
+def get_matching_local_pid(pid: int, verbose: bool):
+    process_cmd = ' '.join(get_pid_info(pid).cmdline)
+    ns_processes = get_ns_processes(pid, verbose)
+    process_list = []
+    for ns_process in ns_processes.processes:
+        ns_process_cmd = ' '.join(ns_process.cmdline)
+        if process_cmd == ns_process_cmd:
+            process_list.append(ns_process)
+    if len(process_list) != 1:
+        raise Exception(f"{len(process_list)} match the pid {pid} args '{process_cmd}'")
+    return process_list[0].pid
+
+def run_jdk_cmd(pid: int, cmd_missing_jdk_path:str, add_local_pid: bool, verbose: bool):
+    with TmpRemotePodMounter(pid, JDK_PATH, LOCAL_MOUNT_PATH, verbose) as jdk_mounter:
+        cmd = cmd_missing_jdk_path
+        if add_local_pid:
+            local_pid = get_matching_local_pid(pid, verbose)
+            cmd = cmd.format(jdk_path=jdk_mounter.get_mounted_jdk_dir(),pid=local_pid)
+        else:
+            cmd = cmd.format(jdk_path=jdk_mounter.get_mounted_jdk_dir())
+        output =  run_cmd_in_proc_namespace(pid, cmd, verbose)
+        typer.echo(output)
+
+
 @app.command()
 def pod_ps(pod_uid: str):
-    app.echo(get_pod_processes(pod_uid).json())
+    typer.echo(get_pod_processes(pod_uid).json())
+
 
 @app.command()
-def pod_ns_ps(pid: str, verbose: bool = True):
-    app.echo(get_ns_processes(pid, verbose).json())
+def pod_ns_ps(pid: int, verbose: bool = False):
+    typer.echo(get_ns_processes(pid, verbose).json())
+
 
 @app.command()
-def jmap(pid: int, verbose: bool = True):
-    with TmpRemotePodMounter(pid, JDK_PATH, LOCAL_MOUNT_PATH, verbose) as jdk_mounter:
-        jstack_cmd = JMAP_CMD.format(jdk_mounter.get_mounted_jdk_dir(), 1)
-        run_cmd_in_proc_namespace(pid, jstack_cmd, verbose)
+def jmap(pid: int, verbose: bool = False):
+    run_jdk_cmd(pid, JMAP_CMD, add_local_pid=True, verbose=verbose)
+
 
 
 @app.command()
-def jstack(pid: int, verbose: bool = True):
-    with TmpRemotePodMounter(pid, JDK_PATH, LOCAL_MOUNT_PATH, verbose) as jdk_mounter:
-        jstack_cmd = JSTACK_CMD.format(jdk_mounter.get_mounted_jdk_dir(), 1)
-        run_cmd_in_proc_namespace(pid, jstack_cmd, verbose)
+def jstack(pid: int, verbose: bool = False):
+    run_jdk_cmd(pid, JSTACK_CMD, add_local_pid=True, verbose=verbose)
+
 
 if __name__ == "__main__":
     app()