PyroLab 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyrolab/__init__.py

@@ -27,6 +27,12 @@ import os
 import pathlib
 import platform
 import sys
+import atexit
+import fileinput
+import re
+from typing import Callable, Iterable
+from time import strptime
+from pathlib import Path
 
 # Check if Python version is supported
 pyversion = sys.version_info
@@ -42,11 +48,11 @@ if pyversion < (3, 7, 0):
 __name__ = "PyroLab"
 __author__ = "CamachoLab"
 __copyright__ = "Copyright 2020, The PyroLab Project"
-__version__ = "0.3.2"
+__version__ = "0.4.0"
 __license__ = "GPLv3+"
 __maintainer__ = "Sequoia Ploeg"
 __maintainer_email__ = "sequoia.ploeg@byu.edu"
-__status__ = "Development" # "Production"
+__status__ = "Development"  # "Production"
 __project_url__ = "https://github.com/sequoiap/pyrolab"
 __forum_url__ = "https://github.com/sequoiap/pyrolab/issues"
 __website_url__ = "https://camacholab.byu.edu/"
@@ -66,6 +72,7 @@ if pyversion < (3, 9, 0):
     base_path = pathlib.Path(__file__).resolve().parent
 else:
     from importlib.resources import files
+
     base_path = files("pyrolab")
 base_path = base_path / "data" / "local"
 
@@ -78,6 +85,7 @@ NAMESERVER_STORAGE.mkdir(parents=True, exist_ok=True)
 
 PYROLAB_LOGDIR = PYROLAB_DATA_DIR / "logs"
 PYROLAB_LOGDIR.mkdir(parents=True, exist_ok=True)
+PYROLAB_MASTERLOG = PYROLAB_LOGDIR / "pyrolab.log"
 
 LOCKFILE = PYROLAB_DATA_DIR / "pyrolabd.lock"
 USER_CONFIG_FILE = PYROLAB_DATA_DIR / "user_configuration.yaml"
@@ -98,11 +106,14 @@ def get_loglevel() -> int:
     return loglevel
 
 
-if len(logging.root.handlers) == 0:    
+if len(logging.root.handlers) == 0:
     logfile = PYROLAB_LOGDIR / f"pyrolab_{os.getpid()}.log"
     root = logging.getLogger()
-    h = logging.handlers.RotatingFileHandler(logfile, 'a', 30000, 10)
-    f = logging.Formatter('[%(asctime)s.%(msecs)03d] %(process)-5s %(processName)-10s %(name)-12s %(levelname)-8s %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
+    h = logging.handlers.RotatingFileHandler(logfile, "a", 30000, 10)
+    f = logging.Formatter(
+        "[%(asctime)s.%(msecs)03d] %(levelname)-8s %(process)-5s %(processName)-16s %(name)-20s %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
     h.setFormatter(f)
     root.addHandler(h)
     root.setLevel(get_loglevel())
@@ -124,10 +135,10 @@ try:
 
     url = "https://pypi.org/pypi/pyrolab/json"
     with requests.Session() as s:
-        s.mount('https://pypi.org', HTTPAdapter(max_retries=3))
+        s.mount("https://pypi.org", HTTPAdapter(max_retries=3))
         resp = s.get(url).text
 
-    v = json.loads(resp)['info']['version']
+    v = json.loads(resp)["info"]["version"]
     curver = parse(__version__)
     latest = parse(v)
 
@@ -139,3 +150,41 @@ try:
         log.info(message)
 except:
     pass
+
+
+def try_itr(func: Callable, itr: Iterable, *exceptions, **kwargs):
+    """
+    Tests a function on an iterable, yields iterable if no exception is raised.
+    """
+    for elem in itr:
+        try:
+            func(elem, **kwargs)
+            yield elem
+        except exceptions:
+            pass
+
+
+# @atexit.register
+# def condense_logs():
+#     """
+#     Cleans up the logfile directory every once in a while.
+
+#     Runs at exit or when "pyrolab down" is called. Condenses all process log
+#     files into a single logfile that is sorted by timestamp.
+#     """
+#     f_names = list(PYROLAB_LOGDIR.glob("*.*"))
+#     lines = list(fileinput.input(f_names))
+#     t_fmt = "%Y-%m-%d %H:%M:%S.%f"  # format of time stamps
+#     t_pat = re.compile(r"\[(.+?)\]")  # pattern to extract timestamp
+#     lines = list(
+#         try_itr(
+#             lambda l: strptime(t_pat.search(l).group(1), t_fmt), lines, AttributeError
+#         )
+#     )
+#     with PYROLAB_MASTERLOG.open(mode="w") as f:
+#         for l in sorted(lines, key=lambda l: strptime(t_pat.search(l).group(1), t_fmt)):
+#             f.write(l)
+#     if PYROLAB_MASTERLOG in f_names:
+#         f_names.remove(PYROLAB_MASTERLOG)
+#     for f in f_names:
+#         f.unlink()

pyrolab/api.py

@@ -14,11 +14,11 @@ from Pyro5.core import locate_ns
 from Pyro5.server import behavior, expose, oneway, serve
 from pyrolab import USER_CONFIG_FILE
 from pyrolab.configure import (
-    PyroLabConfiguration, 
-    NameServerConfiguration, 
-    DaemonConfiguration, 
-    ServiceConfiguration, 
-    reset_config, 
+    PyroLabConfiguration,
+    NameServerConfiguration,
+    DaemonConfiguration,
+    ServiceConfiguration,
+    reset_config,
     update_config,
 )
 from pyrolab.server import Daemon, LockableDaemon
@@ -47,7 +47,7 @@ __all__ = [
 ]
 
 # If a user config file exists, load the first listed nameserver by default,
-# so that locate_ns "just works." 
+# so that locate_ns "just works."
 if USER_CONFIG_FILE.exists():
     cfg = PyroLabConfiguration.from_file(USER_CONFIG_FILE)
     nscfg = next(iter(cfg.nameservers.values()))

pyrolab/cli.py

@@ -20,10 +20,16 @@ import re
 from pathlib import Path
 from typing import Callable, Iterable, Optional
 from time import sleep, strptime
+from tabulate import tabulate
 
-import pkg_resources
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    import pkg_resources
 import typer
+from Pyro5.errors import CommunicationError
 
+import pyrolab
 from pyrolab import LOCKFILE, PYROLAB_LOGDIR, RUNTIME_CONFIG, USER_CONFIG_FILE
 from pyrolab.api import Proxy
 from pyrolab.configure import (
@@ -38,16 +44,23 @@ from pyrolab.pyrolabd import InstanceInfo, PyroLabDaemon
 def get_daemon(abort=True, suppress_reload_message=False) -> PyroLabDaemon:
     if LOCKFILE.exists():
         ii = InstanceInfo.parse_file(LOCKFILE)
-        DAEMON = Proxy(ii.uri)
+        try:
+            DAEMON = Proxy(ii.uri)
+            DAEMON._pyroBind()
+        except CommunicationError:
+            raise ConnectionRefusedError("Could not connect to daemon.")
         if not suppress_reload_message and RUNTIME_CONFIG.exists():
             if RUNTIME_CONFIG.stat().st_mtime < USER_CONFIG_FILE.stat().st_mtime:
                 typer.secho(
                     "The configuration file has been updated. Run 'pyrolab reload' for changes to take effect.",
-                    fg=typer.colors.RED
+                    fg=typer.colors.RED,
                 )
         return DAEMON
     elif abort:
-        typer.secho("PyroLab daemon is not running! Try 'pyrolab up' first.", fg=typer.colors.RED)
+        typer.secho(
+            "PyroLab daemon is not running! Try 'pyrolab up' first.",
+            fg=typer.colors.RED,
+        )
         raise typer.Abort()
     else:
         return None
@@ -55,7 +68,7 @@ def get_daemon(abort=True, suppress_reload_message=False) -> PyroLabDaemon:
 
 ###############################################################################
 # pyrolab Main App
-# 
+#
 # COMMANDS
 # --------
 # pyrolab up
@@ -68,29 +81,49 @@ def get_daemon(abort=True, suppress_reload_message=False) -> PyroLabDaemon:
 app = typer.Typer(no_args_is_help=True)
 
 
-def _version_callback(value: bool=True) -> None:
+def _version_callback(value: bool = True) -> None:
     if value:
         from pyrolab import __version__
+
         typer.echo(f"PyroLab {__version__}")
         raise typer.Exit()
 
-def _show_data_dir(value: bool=True) -> None:
+
+def _show_data_dir(value: bool = True) -> None:
     if value:
         from pyrolab import PYROLAB_DATA_DIR
+
         typer.echo(f"{PYROLAB_DATA_DIR}")
         raise typer.Exit()
 
+
 @app.callback()
 def main(
-    version: bool = typer.Option(False, "--version", "-v", help="Show the version and exit.", callback=_version_callback, is_eager=True),
-    show_data_dir: bool = typer.Option(False, "--data-dir", help="Show the data directories and exit.", callback=_show_data_dir, is_eager=True),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show the version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+    show_data_dir: bool = typer.Option(
+        False,
+        "--data",
+        "-d",
+        help="Show the data directories and exit.",
+        callback=_show_data_dir,
+        is_eager=True,
+    ),
 ):
     return
 
+
 @app.command()
 def up(
-    port: int = typer.Option(None, "--port", "-p", help="Port to use for the PyroLab daemon."),
-    force: bool = typer.Option(False, "--force", "-f", help="Force launch of the daemon (only if you're positive it has died!)."),
+    port: int = typer.Option(
+        None, "--port", "-p", help="Port to use for the PyroLab daemon."
+    ),
 ):
     """
     Start the background PyroLab daemon.
@@ -98,13 +131,21 @@ def up(
     Only use the `--force` flag if you're sure the daemon is dead, or you may
     orphan the process.
     """
-    daemon = get_daemon(abort=False, suppress_reload_message=True)
+    try:
+        daemon = get_daemon(abort=False, suppress_reload_message=True)
+        force = False
+    except ConnectionRefusedError:
+        daemon = None
+        force = True
     if daemon is None or force:
         if force and LOCKFILE.exists():
             LOCKFILE.unlink()
-        
-        rsrc = Path(pkg_resources.resource_filename('pyrolab', "pyrolabd.py"))
-        
+
+        try:
+            rsrc = pkg_resources.files(pyrolab) / "pyrolabd.py"
+        except AttributeError:
+            rsrc = Path(pkg_resources.resource_filename("pyrolab", "pyrolabd.py"))
+
         if port:
             args = [sys.executable, str(rsrc), str(port)]
         else:
@@ -116,15 +157,23 @@ def up(
             # same directory (certainly true for conda installations).
             executable = Path(sys.exec_prefix) / "pythonw.exe"
             args[0] = str(executable)
-            subprocess.Popen(args, close_fds=True, start_new_session=True, creationflags=DETACHED_PROCESS)
+            subprocess.Popen(
+                args,
+                close_fds=True,
+                start_new_session=True,
+                creationflags=DETACHED_PROCESS,
+            )
         else:
-            subprocess.Popen(args, close_fds=True, start_new_session=True) # stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, 
-        
+            subprocess.Popen(
+                args, close_fds=True, start_new_session=True
+            )  # stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+
         typer.secho("PyroLab daemon launched.", fg=typer.colors.GREEN)
     else:
         typer.secho("PyroLab daemon is already running!", fg=typer.colors.RED)
         raise typer.Abort()
 
+
 @app.command()
 def down():
     """
@@ -136,6 +185,7 @@ def down():
         sleep(0.1)
     typer.secho("PyroLab daemon shutdown.", fg=typer.colors.GREEN)
 
+
 @app.command()
 def reload():
     """
@@ -150,6 +200,7 @@ def reload():
     else:
         typer.secho("PyroLab daemon reload failed.", fg=typer.colors.RED)
 
+
 @app.command()
 def ps():
     """
@@ -158,28 +209,38 @@ def ps():
     daemon = get_daemon()
     typer.echo(daemon.ps())
 
+
 ###############################################################################
 # pyrolab config
 ###############################################################################
 
 config_app = typer.Typer()
-app.add_typer(config_app, name="config", help="Configure PyroLab nameservers, daemons, and services.")
+app.add_typer(
+    config_app,
+    name="config",
+    help="Configure PyroLab nameservers, daemons, and services.",
+)
+
 
 @config_app.command("update")
 def config_update(filename: str):
     """Update the configuration file"""
     update_config(filename)
-    
+
+
 @config_app.command("reset")
 def config_reset():
     """Reset the configuration file"""
-    delete = typer.confirm("Are you sure you want to reset the configuration? This cannot be undone.")
+    delete = typer.confirm(
+        "Are you sure you want to reset the configuration? This cannot be undone."
+    )
     if not delete:
         typer.secho("No changes made.", fg=typer.colors.GREEN)
         raise typer.Exit()
     reset_config()
     typer.secho("Configuration reset.", fg=typer.colors.RED)
 
+
 @config_app.command("export")
 def config_export(filename: str):
     """Export the configuration file"""
@@ -189,12 +250,16 @@ def config_export(filename: str):
         typer.secho("No configuration file found.", fg=typer.colors.RED)
         raise typer.Abort()
 
+
 ###############################################################################
 # pyrolab start
 ###############################################################################
 
 start_app = typer.Typer()
-app.add_typer(start_app, name="start", help="Start a nameserver or daemon (and its services).")
+app.add_typer(
+    start_app, name="start", help="Start a nameserver or daemon (and its services)."
+)
+
 
 @start_app.command("nameserver")
 def start_nameserver(name: str):
@@ -204,6 +269,7 @@ def start_nameserver(name: str):
     daemon = get_daemon()
     daemon.start_nameserver(name)
 
+
 @start_app.command("daemon")
 def start_daemon(name: str):
     """
@@ -212,116 +278,110 @@ def start_daemon(name: str):
     daemon = get_daemon()
     daemon.start_daemon(name)
 
+
 ###############################################################################
 # pyrolab stop
 ###############################################################################
 
 stop_app = typer.Typer()
-app.add_typer(stop_app, name="stop", help="Stop a nameserver or daemon (and its services).")
+app.add_typer(
+    stop_app, name="stop", help="Stop a nameserver or daemon (and its services)."
+)
+
 
 @stop_app.command("nameserver")
-def stop_nameserver(name: Optional[str] = typer.Argument(None, help="Name of the service to stop"),):
+def stop_nameserver(
+    name: Optional[str] = typer.Argument(None, help="Name of the service to stop"),
+):
     """
     Stop a nameserver.
     """
     daemon = get_daemon()
     daemon.stop_nameserver(name)
 
+
 @stop_app.command("daemon")
-def stop_daemon(name: Optional[str] = typer.Argument(None, help="Name of the service to stop"),):
+def stop_daemon(
+    name: Optional[str] = typer.Argument(None, help="Name of the service to stop"),
+):
     """
     Stop a daemon.
     """
     daemon = get_daemon()
     daemon.stop_daemon(name)
 
+
 ###############################################################################
 # pyrolab info
 ###############################################################################
 
-info_app = typer.Typer()
-app.add_typer(info_app, name="info", help="Print details about a nameserver, daemon, or service.")
 
-@info_app.command("nameserver")
-def info_nameserver(
-    name: str, 
-):
-    """
-    Get information on a nameserver.
-    """
-    if RUNTIME_CONFIG.exists():
-        config = PyroLabConfiguration.from_file(RUNTIME_CONFIG)
-    elif USER_CONFIG_FILE.exists():
-        config = PyroLabConfiguration.from_file(USER_CONFIG_FILE)
-    else:
-        typer.secho("No configuration file found.", fg=typer.colors.RED)
-        raise typer.Exit()
-
-    if name in config.nameservers:
-        info = textwrap.indent(str(config.nameservers[name].yaml()), '  ')
-        typer.echo(f"{name}\n{info}")
-    else:
-        typer.secho("Nameserver not found.", fg=typer.colors.RED)
-        raise typer.Exit()
-
-@info_app.command("daemon")
-def info_daemon(
-    name: str, 
-):
+@app.command()
+def info():
     """
-    Get information on a daemon.
+    Show details about the current PyroLab configuration.
     """
     if RUNTIME_CONFIG.exists():
         config = PyroLabConfiguration.from_file(RUNTIME_CONFIG)
     elif USER_CONFIG_FILE.exists():
         config = PyroLabConfiguration.from_file(USER_CONFIG_FILE)
     else:
-        typer.secho("No configuration file found.", fg=typer.colors.RED)
+        typer.secho("No configuration installed.", fg=typer.colors.RED)
         raise typer.Exit()
 
-    if name in config.daemons:
-        info = textwrap.indent(str(config.daemons[name].yaml()), '  ')
-        typer.echo(f"{name}\n{info}")
-    else:
-        typer.secho("Daemon not found.", fg=typer.colors.RED)
-        raise typer.Exit()
+    ns_data = []
+    for name in config.nameservers:
+        ns_data.append({"name": name, **config.nameservers[name].dict()})
+    for item in ns_data:
+        item["ns_autoclean"] = (
+            f'{item["ns_autoclean"]} sec' if item["ns_autoclean"] else "Off"
+        )
+    if ns_data:
+        typer.echo("\nNameservers")
+        typer.echo(tabulate(ns_data, headers="keys", tablefmt="rounded_grid"))
+
+    daemon_data = []
+    for name in config.daemons:
+        daemon_data.append({"name": name, **config.daemons[name].dict()})
+    for item in daemon_data:
+        item["nameservers"] = "".join([f"- {name}\n" for name in item["nameservers"]])
+    if daemon_data:
+        typer.echo("\nDaemons")
+        typer.echo(tabulate(daemon_data, headers="keys", tablefmt="rounded_grid"))
+
+    service_data = []
+    for name in config.services:
+        service_data.append({"name": name, **config.services[name].dict()})
+    for item in service_data:
+        item["parameters"] = "".join(
+            [f"{k}: {v}\n" for k, v in item["parameters"].items()]
+        )
+        item["nameservers"] = "".join([f"- {name}\n" for name in item["nameservers"]])
+    if service_data:
+        typer.echo("\nServices")
+        typer.echo(tabulate(service_data, headers="keys", tablefmt="rounded_grid"))
 
-@info_app.command("service")
-def info_service(
-    name: str, 
-):
-    """
-    Get information on a service.
-    """
-    if RUNTIME_CONFIG.exists():
-        config = PyroLabConfiguration.from_file(RUNTIME_CONFIG)
-    elif USER_CONFIG_FILE.exists():
-        config = PyroLabConfiguration.from_file(USER_CONFIG_FILE)
-    else:
-        typer.secho("No configuration file found.", fg=typer.colors.RED)
-        raise typer.Exit()
-
-    if name in config.services:
-        info = textwrap.indent(str(config.services[name].yaml()), '  ')
-        typer.echo(f"{name}\n{info}")
-    else:
-        typer.secho("Service not found.", fg=typer.colors.RED)
-        typer.echo(config.services.keys())
-        raise typer.Exit()
 
 ###############################################################################
 # pyrolab logs
 ###############################################################################
 
 logs_app = typer.Typer()
-app.add_typer(logs_app, name="logs")
+app.add_typer(logs_app, name="logs", help="Compile and export log files.")
+
 
 @logs_app.command("clean")
 def logs_clean():
     """
     Deletes all log files.
     """
-    [f.unlink() for f in PYROLAB_LOGDIR.glob("*.*")]
+    for f in PYROLAB_LOGDIR.glob("*.*"):
+        # Try to delete file if not in use
+        try:
+            f.unlink()
+        except PermissionError:
+            pass
+
 
 def try_itr(func: Callable, itr: Iterable, *exceptions, **kwargs):
     """
@@ -334,21 +394,45 @@ def try_itr(func: Callable, itr: Iterable, *exceptions, **kwargs):
         except exceptions:
             pass
 
+
 @logs_app.command("export")
 def logs_export(filename: str):
     """
     Exports the log file to a file.
     """
-    f_names = PYROLAB_LOGDIR.glob('*.*')
+    f_names = PYROLAB_LOGDIR.glob("*.*")
     lines = list(fileinput.input(f_names))
-    t_fmt = "%Y-%m-%d %H:%M:%S.%f" # format of time stamps
-    t_pat = re.compile(r'\[(.+?)\]') # pattern to extract timestamp
-    lines = list(try_itr(lambda l: strptime(t_pat.search(l).group(1), t_fmt), lines, AttributeError))
-    with Path(filename).open(mode='w') as f:
-        for l in sorted(lines, key=lambda l: strptime(t_pat.search(l).group(1), t_fmt)):
-            f.write(l)
+    t_fmt = "%Y-%m-%d %H:%M:%S.%f"  # format of time stamps
+    t_pat = re.compile(r"\[(.+?)\]")  # pattern to extract timestamp
+
+    # Group lines into log entries
+    log_entries = []
+    current_entry = []
+    for line in lines:
+        # If we've found a new timestamp and we have a current entry, add it to
+        # the list and start a new entry.
+        if t_pat.match(line) and current_entry:
+            log_entries.append("".join(current_entry))
+            current_entry = [line]
+        # Otherwise, keep extending the current entry.
+        else:
+            current_entry.append(line)
+    # Add the last entry to the list
+    if current_entry:
+        log_entries.append("".join(current_entry))
+
+    # Sort log entries by timestamp
+    log_entries = sorted(
+        log_entries, key=lambda entry: strptime(t_pat.search(entry).group(1), t_fmt)
+    )
+
+    # Write sorted log entries to the output file
+    with Path(filename).open(mode="w") as f:
+        for entry in log_entries:
+            f.write(entry)
     typer.secho(f"Exported logs to {filename}", fg=typer.colors.GREEN)
 
+
 ###############################################################################
 # pyrolab rename
 ###############################################################################
@@ -356,10 +440,11 @@ def logs_export(filename: str):
 rename_app = typer.Typer()
 app.add_typer(rename_app, name="rename", help="Rename a nameserver, daemon or service.")
 
+
 @rename_app.command("nameserver")
 def rename_nameserver(
-    old_name: str, 
-    new_name: str, 
+    old_name: str,
+    new_name: str,
 ):
     """
     Rename a nameserver.
@@ -376,10 +461,11 @@ def rename_nameserver(
         typer.secho("No user configuration file found.", fg=typer.colors.RED)
         raise typer.Exit()
 
+
 @rename_app.command("daemon")
 def rename_daemon(
-    old_name: str, 
-    new_name: str, 
+    old_name: str,
+    new_name: str,
 ):
     """
     Rename a daemon.
@@ -396,10 +482,11 @@ def rename_daemon(
         typer.secho("No user configuration file found.", fg=typer.colors.RED)
         raise typer.Exit()
 
+
 @rename_app.command("service")
 def rename_service(
-    old_name: str, 
-    new_name: str, 
+    old_name: str,
+    new_name: str,
 ):
     """
     Rename a service.
@@ -416,6 +503,41 @@ def rename_service(
         typer.secho("No user configuration file found.", fg=typer.colors.RED)
         raise typer.Exit()
 
+
+###############################################################################
+# pyrolab ns_list
+###############################################################################
+
+
+@app.command("nslist")
+def ns_list(
+    host: str = typer.Option(
+        "localhost",
+        "--host",
+        "-h",
+        help="Nameserver host to list all registered services for (default localhost).",
+    ),
+    port: int = typer.Option(
+        9090, "--port", "-p", help="Port to use for the PyroLab daemon (default 9090)."
+    ),
+):
+    """
+    List all services registered with a nameserver.
+    """
+    from pyrolab.api import locate_ns
+
+    ns = locate_ns(host=host, port=port)
+    services = ns.list(return_metadata=True)
+
+    listing = []
+    for k, v in services.items():
+        name = k
+        uri, description = v
+        listing.append([name, uri, ": ".join(description)])
+
+    typer.echo(tabulate(listing, headers=["NAME", "URI", "DESCRIPTION"]))
+
+
 ###############################################################################
 # pyrolab restart
 ###############################################################################