279 lines
7.5 KiB
Python
279 lines
7.5 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""Console script to control the bot_z daemon"""
|
|
|
|
import errno
|
|
import logging
|
|
import os
|
|
import sys
|
|
import typing as T
|
|
|
|
import click
|
|
import lockfile
|
|
|
|
from bot_z.zdaemon import daemon_process
|
|
from bot_z.utils import Fifo, PLifo, cmd_marshal
|
|
|
|
logger = logging.getLogger(__name__)
|
|
logger.setLevel(os.environ.get("BOTZ_LOGLEVEL", logging.INFO))
|
|
sh = logging.StreamHandler(stream=sys.stdout)
|
|
cli_filter = logging.Filter(__name__)
|
|
sh.addFilter(cli_filter)
|
|
sh.setFormatter(logging.Formatter("%(message)s"))
|
|
logger.addHandler(sh)
|
|
|
|
|
|
def _check_name(lifo_path: str, name: T.Optional[str]) -> str:
|
|
with PLifo(lifo_path) as lifo:
|
|
if name is None:
|
|
return lifo.last()
|
|
if name not in lifo:
|
|
logger.error("Daemon not present. Exiting.")
|
|
sys.exit(2)
|
|
return name
|
|
|
|
|
|
@click.group()
|
|
@click.option("-d", "--debug", is_flag=True, default=False, help="Enable debug mode.")
|
|
@click.option(
|
|
"--headless", is_flag=True, default=True, help="Start the clients in headless mode."
|
|
)
|
|
@click.option(
|
|
"-v",
|
|
"--verbose",
|
|
is_flag=True,
|
|
default=False,
|
|
help="More verbose output from this cli.",
|
|
)
|
|
@click.option(
|
|
"-f",
|
|
"--fifo",
|
|
type=click.STRING,
|
|
default="bot_z.cmd",
|
|
help="Path to the control fifo.",
|
|
)
|
|
@click.option(
|
|
"-w",
|
|
"--workdir",
|
|
type=click.Path(exists=True, readable=True, writable=True, resolve_path=True),
|
|
default="/tmp",
|
|
help="The working dir where to launch the daemon and where the lockfile is put.",
|
|
)
|
|
@click.pass_context
|
|
def cli(
|
|
ctx: click.Context,
|
|
debug: bool,
|
|
headless: bool,
|
|
verbose: bool,
|
|
fifo: str,
|
|
workdir: str,
|
|
) -> None:
|
|
"""
|
|
Group cli.
|
|
"""
|
|
if verbose:
|
|
logger.setLevel(logging.DEBUG)
|
|
ctx.ensure_object(dict)
|
|
ctx.obj["debug"] = debug
|
|
ctx.obj["headless"] = headless
|
|
ctx.obj["verbose"] = verbose
|
|
ctx.obj["fifo"] = os.path.join(workdir, fifo)
|
|
ctx.obj["workdir"] = workdir
|
|
ctx.obj["lifo"] = os.path.join(workdir, "botz_open_daemons.list")
|
|
|
|
|
|
@cli.command("start-daemon")
|
|
@click.option(
|
|
"-t", "--timeout", type=click.INT, default=20, help="Browser requests timeout."
|
|
)
|
|
@click.option(
|
|
"-m",
|
|
"--umask",
|
|
type=click.INT,
|
|
default=0o002,
|
|
help="The umask of the control fifo.",
|
|
)
|
|
@click.option(
|
|
"-p",
|
|
"--proxy",
|
|
type=click.STRING,
|
|
default=None,
|
|
help="An optional string for the proxy with the form 'address:port'.",
|
|
)
|
|
@click.option(
|
|
"--foreground",
|
|
is_flag=True,
|
|
default=False,
|
|
help="Keep the process in foreground (do not daemonize).",
|
|
)
|
|
@click.argument("baseuri", type=click.STRING)
|
|
@click.pass_context
|
|
def start_daemon_command(
|
|
ctx: click.Context,
|
|
baseuri: str,
|
|
umask: int,
|
|
timeout: int,
|
|
proxy: T.Optional[str] = None,
|
|
foreground: bool = False,
|
|
) -> None:
|
|
"""
|
|
Invokes daemon_process for the first time.
|
|
"""
|
|
lf = lockfile.FileLock(os.path.join(ctx.obj["workdir"], "bot_z"))
|
|
logger.debug("Daemon starting. Lockfile: %s", lf)
|
|
proxy_tuple = None
|
|
if proxy:
|
|
proxy_tuple = tuple(proxy.split(":"))
|
|
|
|
daemon_process(
|
|
fifo_path=ctx.obj["fifo"],
|
|
working_dir=ctx.obj["workdir"],
|
|
umask=umask,
|
|
pidfile=lf,
|
|
base_uri=baseuri,
|
|
timeout=timeout,
|
|
proxy=proxy_tuple,
|
|
headless=ctx.obj["headless"],
|
|
debug=ctx.obj["debug"],
|
|
foreground=foreground,
|
|
)
|
|
if not foreground:
|
|
logger.info("Daemon started.")
|
|
|
|
|
|
@cli.command("list")
|
|
@click.option(
|
|
"-s",
|
|
"--status",
|
|
is_flag=True,
|
|
default=False,
|
|
help="Show also the status of each client.",
|
|
)
|
|
@click.pass_context
|
|
def list_command(ctx: click.Context, status: bool) -> None:
|
|
"""
|
|
Shows the clients attached
|
|
"""
|
|
logger.debug('Invoked the "list" command.')
|
|
with PLifo(ctx.obj["lifo"]) as lifo:
|
|
if len(lifo) == 0:
|
|
logger.info("No clients.")
|
|
return
|
|
for client in lifo.all():
|
|
logger.info(client)
|
|
if status:
|
|
_status_command(ctx, client)
|
|
|
|
|
|
@cli.command("start")
|
|
@click.option(
|
|
"-n",
|
|
"--name",
|
|
type=click.STRING,
|
|
prompt="Give the instance a name",
|
|
help="The daemon instance name.",
|
|
)
|
|
@click.pass_context
|
|
def start_command(ctx: click.Context, name: str) -> None:
|
|
"""
|
|
Writes on the fifo. Invokes the start of a client.
|
|
"""
|
|
logger.debug("Sending the start command down the pipe: %s", ctx.obj["fifo"])
|
|
with open(ctx.obj["fifo"], "w") as fifo:
|
|
fifo.write(cmd_marshal(name=name, cmd="start"))
|
|
logger.info("Start sent.")
|
|
|
|
|
|
@cli.command("stop-daemon")
|
|
@click.pass_context
|
|
def stop_daemon_command(ctx: click.Context) -> None:
|
|
"""
|
|
Writes on the fifo. Invokes the stop of all the clients and the
|
|
subsequent shutdown of the daemon.
|
|
"""
|
|
logger.debug("Sending the stop-daemon command down the pipe: %s", ctx.obj["fifo"])
|
|
with open(ctx.obj["fifo"], "w") as fifo:
|
|
fifo.write(cmd_marshal(name="", cmd="stop-daemon"))
|
|
logger.info("Stop-daemon sent.")
|
|
|
|
|
|
@cli.command("stop")
|
|
@click.option("-n", "--name", default=None, help="The instance to interact with.")
|
|
@click.pass_context
|
|
def stop_command(ctx: click.Context, name: T.Optional[str]) -> None:
|
|
"""
|
|
Writes on the fifo. Invokes the stop.
|
|
"""
|
|
logger.debug("Sending the stop command down the pipe: %s", ctx.obj["fifo"])
|
|
name = _check_name(ctx.obj["lifo"], name)
|
|
logging.info("Stopping instance: %s", name)
|
|
with open(ctx.obj["fifo"], "w") as fifo:
|
|
fifo.write(cmd_marshal(name=name, cmd="stop"))
|
|
logger.info("Stop sent.")
|
|
|
|
|
|
@cli.command("reload")
|
|
@click.option("-n", "--name", default=None, help="The instance to interact with.")
|
|
@click.pass_context
|
|
def reload_command(ctx: click.Context, name: T.Optional[str]) -> None:
|
|
"""
|
|
Writes on the fifo. Invokes the reload.
|
|
"""
|
|
logger.debug("Sending the reload command down the pipe: %s", ctx.obj["fifo"])
|
|
name = _check_name(ctx.obj["lifo"], name)
|
|
with open(ctx.obj["fifo"], "w") as fifo:
|
|
fifo.write(cmd_marshal(name=name, cmd="reload"))
|
|
logger.info("Reload sent.")
|
|
|
|
|
|
@cli.command("status")
|
|
@click.option("-n", "--name", default=None, help="The instance to interact with.")
|
|
@click.pass_context
|
|
def status_command(ctx: click.Context, name: T.Optional[str]) -> None:
|
|
"""
|
|
Writes on the fifo. Queries the status.
|
|
"""
|
|
try:
|
|
name = _check_name(ctx.obj["lifo"], name)
|
|
except IndexError:
|
|
if len(PLifo.All(ctx.obj["lifo"])) != 0:
|
|
raise
|
|
logger.warning("No clients registered.")
|
|
return
|
|
_status_command(ctx, name)
|
|
|
|
|
|
def _status_command(ctx: click.Context, name: str) -> None:
|
|
rfifo_path = os.path.join(ctx.obj["workdir"], "rfifo-{}".format(id(ctx)))
|
|
logger.debug("Awaiting response on fifo: %s", rfifo_path)
|
|
try:
|
|
os.mkfifo(rfifo_path)
|
|
logger.debug("Response fifo newly created.")
|
|
except OSError as err:
|
|
if err.errno != errno.EEXIST:
|
|
raise
|
|
logger.debug("Response fifo exists.")
|
|
|
|
with Fifo(ctx.obj["fifo"], "w") as fifo:
|
|
fifo.write(cmd_marshal(name=name, cmd="status", rfifo_path=rfifo_path))
|
|
logger.debug("Awaiting response...")
|
|
done = False
|
|
while not done:
|
|
try:
|
|
with open(rfifo_path, "r") as rfifo:
|
|
resp = rfifo.read()
|
|
done = True
|
|
except FileNotFoundError as e:
|
|
logger.warning("File not found: %s", e)
|
|
pass
|
|
logger.info(resp)
|
|
try:
|
|
os.remove(rfifo_path)
|
|
except OSError as e:
|
|
logger.warning("Failed removing response fifo %s: %s", rfifo_path, e)
|
|
pass
|
|
|
|
|
|
if __name__ == "__main__":
|
|
cli()
|