[analyzer] SATest: Add an easy option to connect to docker for debugging

[vsavchenko]

Summary

Docker on its own has a pretty convenient way to run shell.
This method, however, requires target container to be currently running,
which is not a usual scenario for the test system. For this purpose,
it is better to have a simple way to run the container, shell it, and
clean up at the end of it all. New option --shell does exactly this.

[NoQ]

clang/utils/analyzer/entrypoint.py

23

I request comments (:

[vsavchenko]

clang/utils/analyzer/entrypoint.py

23

Yeah, I guess it can be quite confusing when you read only this script :)

[vsavchenko]

Add comments on waiting

[NoQ]

Aha, that explains!

clang/utils/analyzer/SATest.py

 def docker(parser, args):
     if len(args.rest) > 0:
         if args.rest[0] != "--":
             parser.error("REST arguments should start with '--'")
         args.rest = args.rest[1:]
 
     if args.build_image:
         docker_build_image()
+    elif args.shell:
+        docker_shell(args)
     else:
-        docker_run(args)
+        sys.exit(docker_run(args, ' '.join(args.rest)))
 
 
 def docker_build_image():
     sys.exit(call("docker build --tag satest-image {}".format(SCRIPTS_DIR),
                   shell=True))
 
 
-def docker_run(args):
-    sys.exit(call("docker run --rm --name satest "
-                  "-v {llvm}:/llvm-project "
-                  "-v {build}:/build "
-                  "-v {clang}:/analyzer "
-                  "-v {scripts}:/scripts "
-                  "-v {projects}:/projects "
-                  "satest-image:latest {args}"
-                  .format(llvm=args.llvm_project_dir,
-                          build=args.build_dir,
-                          clang=args.clang_dir,
-                          scripts=SCRIPTS_DIR,
-                          projects=PROJECTS_DIR,
-                          args=' '.join(args.rest)),
-                  shell=True))
+def docker_shell(args):
+    try:
+        # First we need to start the docker container in a waiting mode,
+        # so it doesn't do anything, but most importantly keeps working
+        # while the shell session is in progress.
+        docker_run(args, "--wait", "--detach")
+        # Since the docker container is running, we can actually connect to it
+        call("docker exec -it satest bash", shell=True)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        print("Please wait for docker to clean up")
+        call("docker stop satest", shell=True)
+
+
+def docker_run(args, command, docker_args=""):
+    return call("docker run --rm --name satest "
+                "{docker_args} "
+                "satest-image:latest {command}"
+                        docker_args=docker_args,
+                        command=command),
+                shell=True)
 
 
 def main():
     parser = argparse.ArgumentParser()
     subparsers = parser.add_subparsers()
 
     # add subcommand
     add_parser = subparsers.add_parser(

clang/utils/analyzer/entrypoint.py

 import argparse
 import os
 import sys
 
-from typing import List, Tuple
-
 from subprocess import call, check_call, CalledProcessError
+from time import sleep
+from typing import List, Tuple
 
 
 def main():
     settings, rest = parse_arguments()
+    if settings.wait:
+        wait()
     if settings.build_llvm or settings.build_llvm_only:
         build_llvm()
     if settings.build_llvm_only:
         return
     sys.exit(test(rest))
 
 
+def wait():
+    # It is an easy on CPU way of keeping the docker container running
+    # while the user has a terminal session in that container.
+    while True:
+        sleep(3600)
+
+
 def parse_arguments() -> Tuple[argparse.Namespace, List[str]]:
     parser = argparse.ArgumentParser()
+    parser.add_argument('--wait', action='store_true')
     parser.add_argument('--build-llvm', action='store_true')
     parser.add_argument('--build-llvm-only', action='store_true')
     return parser.parse_known_args()
 
 
 def build_llvm():
     os.chdir('/build')
     try: