primitive 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

primitive/daemons/commands.py

@@ -1,7 +1,10 @@
 import click
 
-from ..utils.printer import print_result
 import typing
+from typing import Optional
+from .ui import render_daemon_list
+
+from loguru import logger
 
 if typing.TYPE_CHECKING:
     from ..client import Primitive
@@ -16,50 +19,93 @@ def cli(context):
 
 @cli.command("install")
 @click.pass_context
-def install_daemon_command(context):
+@click.argument(
+    "name",
+    type=str,
+    required=False,
+)
+def install_daemon_command(context, name: Optional[str]):
     """Install the full primitive daemon"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result = primitive.daemons.install()
-    print_result(message=result, context=context)
+    installed = primitive.daemons.install(name=name)
+
+    if installed:
+        logger.info(":white_check_mark: daemon(s) installed successfully!")
+    else:
+        logger.error("Unable to install daemon(s).")
 
 
 @cli.command("uninstall")
 @click.pass_context
-def uninstall_daemon_command(context):
+@click.argument(
+    "name",
+    type=str,
+    required=False,
+)
+def uninstall_daemon_command(context, name: Optional[str]):
     """Uninstall the full primitive Daemon"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result = primitive.daemons.uninstall()
-    print_result(message=result, context=context)
+    uninstalled = primitive.daemons.uninstall(name=name)
+
+    if uninstalled:
+        logger.info(":white_check_mark: daemon(s) uninstalled successfully!")
+    else:
+        logger.error("Unable to uninstall daemon(s).")
 
 
 @cli.command("stop")
 @click.pass_context
-def stop_daemon_command(context):
+@click.argument(
+    "name",
+    type=str,
+    required=False,
+)
+def stop_daemon_command(context, name: Optional[str]):
     """Stop primitive Daemon"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result = primitive.daemons.stop()
-    message = "stopping primitive daemon"
-    if context.obj["JSON"]:
-        message = result
-    print_result(message=message, context=context)
+    stopped = primitive.daemons.stop(name=name)
+
+    if stopped:
+        logger.info(":white_check_mark: daemon(s) stopped successfully!")
+    else:
+        logger.error("Unable to stop daemon(s).")
 
 
 @cli.command("start")
 @click.pass_context
-def start_daemon_command(context):
+@click.argument(
+    "name",
+    type=str,
+    required=False,
+)
+def start_daemon_command(context, name: Optional[str]):
     """Start primitive Daemon"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result = primitive.daemons.start()
-    message = "starting primitive daemon"
-    if context.obj["JSON"]:
-        message = result
-    print_result(message=message, context=context)
+    started = primitive.daemons.start(name=name)
+
+    if started:
+        logger.info(":white_check_mark: daemon(s) started successfully!")
+    else:
+        logger.error("Unable to start daemon(s).")
 
 
 @cli.command("logs")
 @click.pass_context
-def log_daemon_command(context):
+@click.argument(
+    "name",
+    type=str,
+    required=True,
+)
+def log_daemon_command(context, name: str):
     """Logs from primitive Daemon"""
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result = primitive.daemons.logs()
-    print_result(message=result, context=context)
+    primitive.daemons.logs(name=name)
+
+
+@cli.command("list")
+@click.pass_context
+def list_daemon_command(context):
+    """List all daemons"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    daemon_list = primitive.daemons.list()
+    render_daemon_list(daemons=daemon_list)

primitive/daemons/launch_agents.py

@@ -1,102 +1,130 @@
 import os
 from pathlib import Path
 import subprocess
+from loguru import logger
+from ..utils.daemons import Daemon
 
 HOME_DIRECTORY = Path.home()
 CURRENT_USER = str(HOME_DIRECTORY.expanduser()).lstrip("/Users/")
-
 PRIMITIVE_BINARY_PATH = Path(HOME_DIRECTORY / ".pyenv" / "shims" / "primitive")
 
-PRIMITIVE_LAUNCH_AGENT_FILEPATH = Path(
-    HOME_DIRECTORY / "Library" / "LaunchAgents" / "tech.primitive.agent.plist"
-)
-PRIMITIVE_LAUNCH_AGENT_LOGS = Path(
-    HOME_DIRECTORY / "Library" / "Logs" / "tech.primitive.agent.log"
-)
-PRIMITIVE_LAUNCH_AGENT_LABEL = "tech.primitive.agent"
-PRIMITIVE_LAUNCH_AGENT_WORKING_DIR = Path(
-    HOME_DIRECTORY / "Logs" / "tech.primitive.agent.log"
-)
-
-
-def stop_launch_agent():
-    try:
-        stop_existing_process = f"launchctl stop {PRIMITIVE_LAUNCH_AGENT_LABEL}"
-        subprocess.check_output(stop_existing_process.split(" "))
-        return True
-    except subprocess.CalledProcessError as exception:
-        print("stop_launch_agent: ", exception)
-        return False
-
-
-def start_launch_agent():
-    try:
-        start_new_agent = f"launchctl start {PRIMITIVE_LAUNCH_AGENT_LABEL}"
-        subprocess.check_output(start_new_agent.split(" "))
-        return True
-    except subprocess.CalledProcessError as exception:
-        print("start_launch_agent: ", exception)
-        return False
-
-
-def unload_launch_agent():
-    try:
-        remove_existing_agent = f"launchctl unload -w {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
-        subprocess.check_output(remove_existing_agent.split(" "))
-        return True
-    except subprocess.CalledProcessError as exception:
-        print("remove_launch_agent: ", exception)
-        return False
-
-
-def load_launch_agent():
-    try:
-        load_new_plist = f"launchctl load -w {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
-        subprocess.check_output(load_new_plist.split(" "))
-        return True
-    except subprocess.CalledProcessError as exception:
-        print("load_launch_agent: ", exception)
-        return False
-
-
-def create_stdout_file():
-    if not PRIMITIVE_LAUNCH_AGENT_LOGS.exists():
-        PRIMITIVE_LAUNCH_AGENT_LOGS.parent.mkdir(parents=True, exist_ok=True)
-        PRIMITIVE_LAUNCH_AGENT_LOGS.touch()
-
-
-def delete_stdout_file():
-    if PRIMITIVE_LAUNCH_AGENT_LOGS.exists():
-        PRIMITIVE_LAUNCH_AGENT_LOGS.unlink()
-
-
-def populate_fresh_launch_agent():
-    PRIMITIVE_LAUNCH_AGENT_LOGS.parent.mkdir(parents=True, exist_ok=True)
-    PRIMITIVE_LAUNCH_AGENT_LOGS.touch()
-
-    if PRIMITIVE_LAUNCH_AGENT_FILEPATH.exists():
-        PRIMITIVE_LAUNCH_AGENT_FILEPATH.unlink()
-    PRIMITIVE_LAUNCH_AGENT_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
-    PRIMITIVE_LAUNCH_AGENT_FILEPATH.touch()
-
-    found_primitive_binary_path = PRIMITIVE_BINARY_PATH
-    if not PRIMITIVE_BINARY_PATH.exists():
-        result = subprocess.run(["which", "primitive"], capture_output=True)
-        if result.returncode == 0:
-            found_primitive_binary_path = result.stdout.decode().rstrip("\n")
-        else:
-            print("primitive binary not found")
+
+class LaunchAgent(Daemon):
+    def __init__(self, label: str):
+        self.label = label
+        self.name = label.split(".")[-1]
+
+    @property
+    def file_path(self) -> Path:
+        return Path(HOME_DIRECTORY / "Library" / "LaunchAgents" / f"{self.label}.plist")
+
+    @property
+    def logs(self) -> Path:
+        return Path(HOME_DIRECTORY / "Library" / "Logs" / f"{self.label}.log")
+
+    @property
+    def cmd(self) -> str:
+        return self.label.split(".")[-1]
+
+    def stop(self, unload: bool = True) -> bool:
+        try:
+            stop_existing_process = f"launchctl stop {self.label}"
+            subprocess.check_output(
+                stop_existing_process.split(" "), stderr=subprocess.DEVNULL
+            )
+            logger.info(f":white_check_mark: {self.label} stopped successfully!")
+            if unload:
+                self.unload()  # Need to unload with KeepAlive = true or else launchctl will try to pick it up again
+            return True
+        except subprocess.CalledProcessError as exception:
+            if exception.returncode == 3:
+                logger.debug(f"{self.label} is not running or does not exist.")
+                return True
+            else:
+                logger.error(f"Unable to stop {self.label}, {exception.returncode}")
+                logger.error(exception)
+                return False
+
+    def start(self, load: bool = True) -> bool:
+        if load:
+            self.load()
+        try:
+            start_new_agent = f"launchctl start {self.label}"
+            subprocess.check_output(
+                start_new_agent.split(" "), stderr=subprocess.DEVNULL
+            )
+            logger.info(f":white_check_mark: {self.label} started successfully!")
+            return True
+        except subprocess.CalledProcessError as exception:
+            logger.error(f"Unable to start {self.label}")
+            logger.error(exception)
+            return False
+
+    def unload(self) -> bool:
+        try:
+            remove_existing_agent = f"launchctl unload -w {self.file_path}"
+            subprocess.check_output(
+                remove_existing_agent.split(" "), stderr=subprocess.DEVNULL
+            )
+            return True
+        except subprocess.CalledProcessError as exception:
+            logger.error(f"Unable to unload {self.label}")
+            logger.error(exception)
+            return False
+
+    def load(self) -> bool:
+        try:
+            load_new_plist = f"launchctl load -w {self.file_path}"
+            subprocess.check_output(
+                load_new_plist.split(" "), stderr=subprocess.DEVNULL
+            )
+            return True
+        except subprocess.CalledProcessError as exception:
+            logger.error(f"Unable to load {self.label}")
+            logger.error(exception)
+            return False
+
+    def verify(self) -> bool:
+        plutil_check = f"plutil -lint {self.file_path}"
+        try:
+            subprocess.check_output(plutil_check.split(" "), stderr=subprocess.DEVNULL)
+            return True
+        except subprocess.CalledProcessError as exception:
+            logger.error(f"Unable to verify {self.label}")
+            logger.error(exception)
             return False
 
-    PRIMITIVE_LAUNCH_AGENT_FILEPATH.write_text(
-        f"""<?xml version="1.0" encoding="UTF-8"?>
+    def view_logs(self) -> None:
+        follow_logs = f"tail -f -n +1 {self.logs}"
+        os.system(follow_logs)
+
+    def populate(self) -> bool:
+        self.logs.parent.mkdir(parents=True, exist_ok=True)
+        self.logs.touch()
+
+        if self.file_path.exists():
+            self.file_path.unlink()
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        self.file_path.touch()
+
+        found_primitive_binary_path = PRIMITIVE_BINARY_PATH
+        if not PRIMITIVE_BINARY_PATH.exists():
+            result = subprocess.run(["which", "primitive"], capture_output=True)
+            if result.returncode == 0:
+                found_primitive_binary_path = result.stdout.decode().rstrip("\n")
+            else:
+                logger.error("primitive binary not found")
+                return False
+
+        self.file_path.write_text(
+            f"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
     <key>KeepAlive</key>
     <true/>
     <key>Label</key>
-    <string>{PRIMITIVE_LAUNCH_AGENT_LABEL}</string>
+    <string>{self.label}</string>
     <key>LimitLoadToSessionType</key>
 	<array>
 		<string>Aqua</string>
@@ -107,48 +135,103 @@ def populate_fresh_launch_agent():
     <key>ProgramArguments</key>
     <array>
         <string>{found_primitive_binary_path}</string>
-        <string>agent</string>
+        <string>{self.cmd}</string>
     </array>
     <key>RunAtLoad</key>
     <true/>
     <key>StandardErrorPath</key>
-    <string>{PRIMITIVE_LAUNCH_AGENT_LOGS}</string>
+    <string>{self.logs}</string>
     <key>StandardOutPath</key>
-    <string>{PRIMITIVE_LAUNCH_AGENT_LOGS}</string>
+    <string>{self.logs}</string>
 </dict>
-</plist>"""  # noqa: E501
-    )
-    PRIMITIVE_LAUNCH_AGENT_FILEPATH.chmod(0o644)
-    verify_launch_agent()
-
-
-def verify_launch_agent():
-    plutil_check = f"plutil -lint {PRIMITIVE_LAUNCH_AGENT_FILEPATH}"
-    try:
-        subprocess.check_output(plutil_check.split(" "))
-        return True
-    except subprocess.CalledProcessError as exception:
-        print("verify_launch_agent: ", exception)
-        return False
-
-
-def view_launch_agent_logs():
-    follow_logs = f"tail -f -n +1 {PRIMITIVE_LAUNCH_AGENT_LOGS}"
-    os.system(follow_logs)
-
-
-def full_launch_agent_install():
-    stop_launch_agent()
-    unload_launch_agent()
-    populate_fresh_launch_agent()
-    create_stdout_file()
-    load_launch_agent()
-    start_launch_agent()
-
-
-def full_launch_agent_uninstall():
-    stop_launch_agent()
-    unload_launch_agent()
-    if PRIMITIVE_LAUNCH_AGENT_FILEPATH.exists():
-        PRIMITIVE_LAUNCH_AGENT_FILEPATH.unlink()
-    delete_stdout_file()
+</plist>"""
+        )
+        self.file_path.chmod(0o644)
+        return self.verify()
+
+    def create_stdout_file(self) -> bool:
+        try:
+            if not self.logs.exists():
+                self.logs.parent.mkdir(parents=True, exist_ok=True)
+                self.logs.touch()
+            return True
+        except Exception as e:
+            logger.error(
+                f"Unable to create log file at {self.logs} for daemon {self.label}"
+            )
+            logger.error(e)
+            return False
+
+    def delete_stdout_file(self) -> bool:
+        try:
+            if self.logs.exists():
+                self.logs.unlink()
+            return True
+        except Exception as e:
+            logger.error(
+                f"Unable to delete log file at {self.logs} for daemon {self.label}"
+            )
+            logger.error(e)
+            return False
+
+    def delete_plist_file(self) -> bool:
+        try:
+            if self.file_path.exists():
+                self.file_path.unlink()
+            return True
+        except Exception as e:
+            logger.error(
+                f"Unable to delete log file at {self.logs} for daemon {self.label}"
+            )
+            logger.error(e)
+            return False
+
+    def install(self) -> bool:
+        return all(
+            [
+                self.stop(),
+                self.unload(),
+                self.populate(),
+                self.create_stdout_file(),
+                self.load(),
+                self.start(load=False),
+            ]
+        )
+
+    def uninstall(self) -> bool:
+        return all(
+            [
+                self.stop(unload=False),
+                self.unload(),
+                self.delete_plist_file(),
+                self.delete_stdout_file(),
+            ]
+        )
+
+    def is_active(self) -> bool:
+        if not self.is_installed():
+            return False
+
+        try:
+            is_service_active = f"launchctl list {self.label}"  # noqa
+            output = (
+                subprocess.check_output(is_service_active.split(" ")).decode().strip()
+            )
+            return "PID" in output
+        except subprocess.CalledProcessError as exception:
+            logger.error(f"Unable to check if {self.label} active")
+            logger.error(exception)
+            return False
+
+    def is_installed(self) -> bool:
+        try:
+            is_service_active = f"launchctl list {self.label}"  # noqa
+            subprocess.check_output(
+                is_service_active.split(" "), stderr=subprocess.DEVNULL
+            )
+            return True
+        except subprocess.CalledProcessError as exception:
+            if exception.returncode != 113:
+                logger.error(f"Unable to check if {self.label} enabled")
+                logger.error(exception)
+            return False