qlever 0.5.12__py3-none-any.whl → 0.5.17__py3-none-any.whl

qlever/commands/start.py

@@ -13,6 +13,110 @@ from qlever.log import log
 from qlever.util import is_qlever_server_alive, run_command
 
 
+# Construct the command line based on the config file.
+def construct_command(args) -> str:
+    start_cmd = (
+        f"{args.server_binary}"
+        f" -i {args.name}"
+        f" -j {args.num_threads}"
+        f" -p {args.port}"
+        f" -m {args.memory_for_queries}"
+        f" -c {args.cache_max_size}"
+        f" -e {args.cache_max_size_single_entry}"
+        f" -k {args.cache_max_num_entries}"
+    )
+
+    if args.timeout:
+        start_cmd += f" -s {args.timeout}"
+    if args.access_token:
+        start_cmd += f" -a {args.access_token}"
+    if args.only_pso_and_pos_permutations:
+        start_cmd += " --only-pso-and-pos-permutations"
+    if not args.use_patterns:
+        start_cmd += " --no-patterns"
+    if args.use_text_index == "yes":
+        start_cmd += " -t"
+    start_cmd += f" > {args.name}.server-log.txt 2>&1"
+    return start_cmd
+
+
+# Kill existing server on the same port. Trust that StopCommand() works?
+# Maybe return StopCommand().execute(args) and handle it with a try except?
+def kill_existing_server(args) -> bool:
+    args.cmdline_regex = f"^ServerMain.* -p {args.port}"
+    args.no_containers = True
+    if not StopCommand().execute(args):
+        log.error("Stopping the existing server failed")
+        return False
+    log.info("")
+    return True
+
+
+# Run the command in a container
+def wrap_command_in_container(args, start_cmd) -> str:
+    if not args.server_container:
+        args.server_container = f"qlever.server.{args.name}"
+    start_cmd = Containerize().containerize_command(
+        start_cmd,
+        args.system,
+        "run -d --restart=unless-stopped",
+        args.image,
+        args.server_container,
+        volumes=[("$(pwd)", "/index")],
+        ports=[(args.port, args.port)],
+        working_directory="/index",
+    )
+    return start_cmd
+
+
+# When running natively, check if the binary exists and works.
+def check_binary(binary) -> bool:
+    try:
+        run_command(f"{binary} --help")
+        return True
+    except Exception as e:
+        log.error(
+            f'Running "{binary}" failed, '
+            f"set `--server-binary` to a different binary or "
+            f"set `--system to a container system`"
+        )
+        log.info("")
+        log.info(f"The error message was: {e}")
+        return False
+
+
+# Set the index description.
+def set_index_description(access_arg, port, desc) -> bool:
+    curl_cmd = (
+        f"curl -Gs http://localhost:{port}/api"
+        f' --data-urlencode "index-description={desc}"'
+        f" {access_arg} > /dev/null"
+    )
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+    except Exception as e:
+        log.error(f"Setting the index description failed ({e})")
+        return False
+    return True
+
+
+# Set the text description.
+def set_text_description(access_arg, port, text_desc) -> bool:
+    curl_cmd = (
+        f"curl -Gs http://localhost:{port}/api"
+        f' --data-urlencode "text-description={text_desc}"'
+        f" {access_arg} > /dev/null"
+    )
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+    except Exception as e:
+        log.error(f"Setting the text description failed ({e})")
+        return False
+    return True
+
+
 class StartCommand(QleverCommand):
     """
     Class for executing the `start` command.
@@ -22,22 +126,35 @@ class StartCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return ("Start the QLever server (requires that you have built "
-                "an index with `qlever index` before)")
+        return (
+            "Start the QLever server (requires that you have built "
+            "an index with `qlever index` before)"
+        )
 
     def should_have_qleverfile(self) -> bool:
         return True
 
-    def relevant_qleverfile_arguments(self) -> dict[str: list[str]]:
-        return {"data": ["name", "description", "text_description"],
-                "server": ["server_binary", "host_name", "port",
-                           "access_token", "memory_for_queries",
-                           "cache_max_size", "cache_max_size_single_entry",
-                           "cache_max_num_entries", "num_threads",
-                           "timeout", "only_pso_and_pos_permutations",
-                           "use_patterns", "use_text_index",
-                           "warmup_cmd"],
-                "runtime": ["system", "image", "server_container"]}
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
+        return {
+            "data": ["name", "description", "text_description"],
+            "server": [
+                "server_binary",
+                "host_name",
+                "port",
+                "access_token",
+                "memory_for_queries",
+                "cache_max_size",
+                "cache_max_size_single_entry",
+                "cache_max_num_entries",
+                "num_threads",
+                "timeout",
+                "only_pso_and_pos_permutations",
+                "use_patterns",
+                "use_text_index",
+                "warmup_cmd",
+            ],
+            "runtime": ["system", "image", "server_container"],
+        }
 
     def additional_arguments(self, subparser) -> None:
         # subparser.add_argument("--kill-existing-with-same-name",
@@ -46,16 +163,27 @@ class StartCommand(QleverCommand):
         #                        help="If a QLever server is already running "
         #                             "with the same name, kill it before "
         #                             "starting a new server")
-        subparser.add_argument("--kill-existing-with-same-port",
-                               action="store_true",
-                               default=False,
-                               help="If a QLever server is already running "
-                                    "on the same port, kill it before "
-                                    "starting a new server")
-        subparser.add_argument("--no-warmup",
-                               action="store_true",
-                               default=False,
-                               help="Do not execute the warmup command")
+        subparser.add_argument(
+            "--kill-existing-with-same-port",
+            action="store_true",
+            default=False,
+            help="If a QLever server is already running "
+            "on the same port, kill it before "
+            "starting a new server",
+        )
+        subparser.add_argument(
+            "--no-warmup",
+            action="store_true",
+            default=False,
+            help="Do not execute the warmup command",
+        )
+        subparser.add_argument(
+            "--run-in-foreground",
+            action="store_true",
+            default=False,
+            help="Run the server in the foreground "
+            "(default: run in the background with `nohup`)",
+        )
 
     def execute(self, args) -> bool:
         # Kill existing server with the same name if so desired.
@@ -70,84 +198,57 @@ class StartCommand(QleverCommand):
 
         # Kill existing server on the same port if so desired.
         if args.kill_existing_with_same_port:
-            args.cmdline_regex = f"^ServerMain.* -p {args.port}"
-            args.no_containers = True
-            StopCommand().execute(args)
-            log.info("")
+            if args.kill_existing_with_same_port and not kill_existing_server(
+                args
+            ):
+                return False
 
         # Construct the command line based on the config file.
-        start_cmd = (f"{args.server_binary}"
-                     f" -i {args.name}"
-                     f" -j {args.num_threads}"
-                     f" -p {args.port}"
-                     f" -m {args.memory_for_queries}"
-                     f" -c {args.cache_max_size}"
-                     f" -e {args.cache_max_size_single_entry}"
-                     f" -k {args.cache_max_num_entries}")
-        if args.timeout:
-            start_cmd += f" -s {args.timeout}"
-        if args.access_token:
-            start_cmd += f" -a {args.access_token}"
-        if args.only_pso_and_pos_permutations:
-            start_cmd += " --only-pso-and-pos-permutations"
-        if not args.use_patterns:
-            start_cmd += " --no-patterns"
-        if args.use_text_index == "yes":
-            start_cmd += " -t"
-        start_cmd += f" > {args.name}.server-log.txt 2>&1"
+        start_cmd = construct_command(args)
 
         # Run the command in a container (if so desired). Otherwise run with
-        # `nohup` so that it keeps running after the shell is closed.
+        # `nohup` so that it keeps running after the shell is closed. With
+        # `--run-in-foreground`, run the server in the foreground.
         if args.system in Containerize.supported_systems():
-            if not args.server_container:
-                args.server_container = f"qlever.server.{args.name}"
-            start_cmd = Containerize().containerize_command(
-                    start_cmd,
-                    args.system, "run -d --restart=unless-stopped",
-                    args.image,
-                    args.server_container,
-                    volumes=[("$(pwd)", "/index")],
-                    ports=[(args.port, args.port)],
-                    working_directory="/index")
+            start_cmd = wrap_command_in_container(args, start_cmd)
+        elif args.run_in_foreground:
+            start_cmd = f"{start_cmd}"
         else:
             start_cmd = f"nohup {start_cmd} &"
 
         # Show the command line.
         self.show(start_cmd, only_show=args.show)
         if args.show:
-            return False
+            return True
 
         # When running natively, check if the binary exists and works.
         if args.system == "native":
-            try:
-                run_command(f"{args.server_binary} --help")
-            except Exception as e:
-                log.error(f"Running \"{args.server_binary}\" failed, "
-                          f"set `--server-binary` to a different binary or "
-                          f"set `--system to a container system`")
-                log.info("")
-                log.info(f"The error message was: {e}")
+            ret = check_binary(args.server_binary)
+            if not ret:
                 return False
 
         # Check if a QLever server is already running on this port.
-        port = args.port
-        if is_qlever_server_alive(port):
-            log.error(f"QLever server already running on port {port}")
+        endpoint_url = f"http://localhost:{args.port}"
+        if is_qlever_server_alive(endpoint_url):
+            log.error(f"QLever server already running on {endpoint_url}")
             log.info("")
-            log.info("To kill the existing server, use `qlever stop` "
-                     "or `qlever start` with option "
-                     "--kill-existing-with-same-port`")
+            log.info(
+                "To kill the existing server, use `qlever stop` "
+                "or `qlever start` with option "
+                "--kill-existing-with-same-port`"
+            )
 
             # Show output of status command.
-            args.cmdline_regex = f"^ServerMain.* -p *{port}"
+            args.cmdline_regex = f"^ServerMain.* -p *{args.port}"
             log.info("")
             StatusCommand().execute(args)
-
             return False
 
         # Remove already existing container.
-        if args.system in Containerize.supported_systems() \
-                and args.kill_existing_with_same_port:
+        if (
+            args.system in Containerize.supported_systems()
+            and args.kill_existing_with_same_port
+        ):
             try:
                 run_command(f"{args.system} rm -f {args.server_container}")
             except Exception as e:
@@ -164,7 +265,10 @@ class StartCommand(QleverCommand):
 
         # Execute the command line.
         try:
-            run_command(start_cmd)
+            process = run_command(
+                start_cmd,
+                use_popen=args.run_in_foreground,
+            )
         except Exception as e:
             log.error(f"Starting the QLever server failed ({e})")
             return False
@@ -172,48 +276,61 @@ class StartCommand(QleverCommand):
         # Tail the server log until the server is ready (note that the `exec`
         # is important to make sure that the tail process is killed and not
         # just the bash process).
-        log.info(f"Follow {args.name}.server-log.txt until the server is ready"
-                 f" (Ctrl-C stops following the log, but not the server)")
+        if args.run_in_foreground:
+            log.info(
+                f"Follow {args.name}.server-log.txt as long as the server is"
+                f" running (Ctrl-C stops the server)"
+            )
+        else:
+            log.info(
+                f"Follow {args.name}.server-log.txt until the server is ready"
+                f" (Ctrl-C stops following the log, but NOT the server)"
+            )
         log.info("")
         tail_cmd = f"exec tail -f {args.name}.server-log.txt"
         tail_proc = subprocess.Popen(tail_cmd, shell=True)
-        while not is_qlever_server_alive(port):
+        while not is_qlever_server_alive(endpoint_url):
             time.sleep(1)
 
-        # Set the access token if specified.
-        access_arg = f"--data-urlencode \"access-token={args.access_token}\""
+        # Set the description for the index and text.
+        access_arg = f'--data-urlencode "access-token={args.access_token}"'
         if args.description:
-            desc = args.description
-            curl_cmd = (f"curl -Gs http://localhost:{port}/api"
-                        f" --data-urlencode \"index-description={desc}\""
-                        f" {access_arg} > /dev/null")
-            log.debug(curl_cmd)
-            try:
-                run_command(curl_cmd)
-            except Exception as e:
-                log.error(f"Setting the index description failed ({e})")
+            ret = set_index_description(
+                access_arg, args.port, args.description
+            )
+            if not ret:
+                return False
         if args.text_description:
-            text_desc = args.text_description
-            curl_cmd = (f"curl -Gs http://localhost:{port}/api"
-                        f" --data-urlencode \"text-description={text_desc}\""
-                        f" {access_arg} > /dev/null")
-            log.debug(curl_cmd)
-            try:
-                run_command(curl_cmd)
-            except Exception as e:
-                log.error(f"Setting the text description failed ({e})")
+            ret = set_text_description(
+                access_arg, args.port, args.text_description
+            )
+            if not ret:
+                return False
 
         # Kill the tail process. NOTE: `tail_proc.kill()` does not work.
-        tail_proc.terminate()
+        if not args.run_in_foreground:
+            tail_proc.terminate()
 
         # Execute the warmup command.
         if args.warmup_cmd and not args.no_warmup:
             log.info("")
-            WarmupCommand().execute(args)
+            if not WarmupCommand().execute(args):
+                log.error("Warmup failed")
+                return False
 
         # Show cache stats.
-        log.info("")
-        args.detailed = False
-        args.server_url = None
-        CacheStatsCommand().execute(args)
+        if not args.run_in_foreground:
+            log.info("")
+            args.detailed = False
+            args.server_url = None
+            CacheStatsCommand().execute(args)
+
+        # With `--run-in-foreground`, wait until the server is stopped.
+        if args.run_in_foreground:
+            try:
+                process.wait()
+            except KeyboardInterrupt:
+                process.terminate()
+            tail_proc.terminate()
+
         return True

qlever/commands/status.py

@@ -35,7 +35,7 @@ class StatusCommand(QleverCommand):
                   f"the command line matches {args.cmdline_regex}"
                   f" using Python's psutil library", only_show=args.show)
         if args.show:
-            return False
+            return True
 
         # Show the results as a table.
         num_processes_found = 0
@@ -47,3 +47,4 @@ class StatusCommand(QleverCommand):
                 num_processes_found += 1
         if num_processes_found == 0:
             print("No processes found")
+        return True

qlever/commands/stop.py

@@ -1,15 +1,40 @@
 from __future__ import annotations
-
 import re
-
 import psutil
-
 from qlever.command import QleverCommand
 from qlever.commands.status import StatusCommand
 from qlever.containerize import Containerize
 from qlever.log import log
 from qlever.util import show_process_info
 
+# try to kill the given process, return true iff it was killed successfully.
+# the process_info is used for logging.
+def stop_process(proc, pinfo):
+    try:
+        proc.kill()
+        log.info(f"Killed process {pinfo['pid']}")
+        return True
+    except Exception as e:
+        log.error(f"Could not kill process with PID "
+                  f"{pinfo['pid']} ({e}) ... try to kill it "
+                  f"manually")
+        log.info("")
+        show_process_info(proc, "", show_heading=True)
+        return False
+
+
+# try to stop and remove container. return True iff it was stopped
+# successfully. Gives log info accordingly.
+def stop_container(server_container):
+    for container_system in Containerize.supported_systems():
+        if Containerize.stop_and_remove_container(
+                container_system, server_container):
+            log.info(f"{container_system.capitalize()} container with "
+                     f"name \"{server_container}\" stopped "
+                     f" and removed")
+            return True
+    return False
+
 
 class StopCommand(QleverCommand):
     """
@@ -20,7 +45,7 @@ class StopCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return ("Stop QLever server for a given datasedataset or port")
+        return "Stop QLever server for a given datasedataset or port"
 
     def should_have_qleverfile(self) -> bool:
         return True
@@ -49,55 +74,41 @@ class StopCommand(QleverCommand):
                             f"\"{args.server_container}\"")
         self.show(description, only_show=args.show)
         if args.show:
-            return False
+            return True
 
         # First check if there is container running and if yes, stop and remove
         # it (unless the user has specified `--no-containers`).
         if not args.no_containers:
-            for container_system in Containerize.supported_systems():
-                if Containerize.stop_and_remove_container(
-                        container_system, args.server_container):
-                    log.info(f"{container_system.capitalize()} container with "
-                             f"name \"{args.server_container}\" stopped "
-                             f" and removed")
-                    return True
+            if stop_container(args.server_container):
+                return True
 
         # Check if there is a process running on the server port using psutil.
-        #
         # NOTE: On MacOS, some of the proc's returned by psutil.process_iter()
         # no longer exist when we try to access them, so we just skip them.
+        stop_process_results = []
         for proc in psutil.process_iter():
             try:
                 pinfo = proc.as_dict(
-                        attrs=['pid', 'username', 'create_time',
-                               'memory_info', 'cmdline'])
+                    attrs=['pid', 'username', 'create_time',
+                           'memory_info', 'cmdline'])
                 cmdline = " ".join(pinfo['cmdline'])
             except Exception as e:
                 log.debug(f"Error getting process info: {e}")
+                return False
             if re.search(cmdline_regex, cmdline):
                 log.info(f"Found process {pinfo['pid']} from user "
                          f"{pinfo['username']} with command line: {cmdline}")
                 log.info("")
-                try:
-                    proc.kill()
-                    log.info(f"Killed process {pinfo['pid']}")
-                except Exception as e:
-                    log.error(f"Could not kill process with PID "
-                              f"{pinfo['pid']} ({e}) ... try to kill it "
-                              f"manually")
-                    log.info("")
-                    show_process_info(proc, "", show_heading=True)
-                    return False
-                return True
+                stop_process_results.append(stop_process(proc, pinfo))
+        if len(stop_process_results) > 0:
+            return all(stop_process_results)
 
-        # No matching process found.
+        # If no matching process found, show a message and the output of the
+        # status command.
         message = "No matching process found" if args.no_containers else \
-                  "No matching process or container found"
+            "No matching process or container found"
         log.error(message)
-
-        # Show output of status command.
         args.cmdline_regex = "^ServerMain.* -i [^ ]*"
         log.info("")
         StatusCommand().execute(args)
-
-        return False
+        return True

qlever/commands/system_info.py

@@ -58,7 +58,7 @@ class SystemInfoCommand(QleverCommand):
         # Say what the command is doing.
         self.show("Show system information and Qleverfile", only_show=args.show)
         if args.show:
-            return False
+            return True
 
         # Show system information.
         show_heading("System Information")

qlever/commands/ui.py

@@ -70,8 +70,10 @@ class UiCommand(QleverCommand):
             "\n".join(["Stop running containers", pull_cmd, run_cmd, exec_cmd]),
             only_show=args.show,
         )
-        if qlever_is_running_in_container or args.show:
+        if qlever_is_running_in_container:
             return False
+        if args.show:
+            return True
 
         # Stop running containers.
         for container_system in Containerize.supported_systems():

qlever/commands/warmup.py

@@ -30,7 +30,7 @@ class WarmupCommand(QleverCommand):
         # Show what the command is doing.
         self.show(args.warmup_cmd, only_show=args.show)
         if args.show:
-            return False
+            return True
 
         # Execute the command.
         try:

qlever/qlever_main.py

@@ -35,31 +35,38 @@ def main():
         log.info("")
         log.info(colored(f"Command: {args.command}", attrs=["bold"]))
         log.info("")
-        command_object.execute(args)
+        commandWasSuccesful = command_object.execute(args)
         log.info("")
+        if not commandWasSuccesful:
+            exit(1)
     except KeyboardInterrupt:
         log.info("")
         log.info("Ctrl-C pressed, exiting ...")
         log.info("")
-        exit(0)
+        exit(1)
     except Exception as e:
         # Check if it's a certain kind of `AttributeError` and give a hint in
         # that case.
         match_error = re.search(r"object has no attribute '(.+)'", str(e))
-        match_trace = re.search(r"(qlever/commands/.+\.py)\", line (\d+)",
-                                traceback.format_exc())
+        match_trace = re.search(
+            r"(qlever/commands/.+\.py)\", line (\d+)", traceback.format_exc()
+        )
         if isinstance(e, AttributeError) and match_error and match_trace:
             attribute = match_error.group(1)
             trace_command = match_trace.group(1)
             trace_line = match_trace.group(2)
             log.error(f"{e} in `{trace_command}` at line {trace_line}")
             log.info("")
-            log.info(f"Likely cause: you used `args.{attribute}`, but it was "
-                     f"neither defined in `relevant_qleverfile_arguments` "
-                     f"nor in `additional_arguments`")
+            log.info(
+                f"Likely cause: you used `args.{attribute}`, but it was "
+                f"neither defined in `relevant_qleverfile_arguments` "
+                f"nor in `additional_arguments`"
+            )
             log.info("")
-            log.info(f"If you did not implement `{trace_command}` yourself, "
-                     f"please report this issue")
+            log.info(
+                f"If you did not implement `{trace_command}` yourself, "
+                f"please report this issue"
+            )
             log.info("")
         else:
             log.error(f"An unexpected error occurred: {e}")