flask-nginx 0.8.0__py3-none-any.whl

flask_nginx/__main__.py

@@ -0,0 +1,19 @@
+# pylint: disable=unused-import
+from __future__ import annotations
+
+from . import irds  # noqa:
+from . import mailer  # noqa:
+from . import mysql  # noqa:
+from . import remote  # noqa:
+from . import restartd  # noqa:
+from . import rsync  # noqa:
+from . import watch  # noqa:
+from .cli import cli
+from .systemd import nginx  # noqa:
+from .systemd import supervisor  # noqa:
+from .systemd import systemd  # noqa:
+
+# from . import logo  # noqa:
+
+if __name__ == "__main__":
+    cli.main(prog_name="footprint")

flask_nginx/cli.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import subprocess
+
+import click
+
+
+@click.group(
+    # cls=DYMGroup,
+    epilog=click.style("Commands to manage websites\n", fg="magenta"),
+)
+@click.version_option()
+def cli() -> None:
+    pass
+
+
+@cli.command()
+def update() -> None:
+    """Update this package"""
+    import sys
+
+    from .config import REPO
+
+    ret = subprocess.call([sys.executable, "-m", "pip", "install", "-U", REPO])
+    if ret:
+        click.secho(f"can't install {REPO}", fg="red")
+        raise click.Abort()
+
+
+@cli.command()
+def repo() -> None:
+    """show git repository"""
+
+    from .config import REPO
+
+    click.echo(REPO)
+
+
+@cli.command()
+def config_show() -> None:
+    """Show configuration"""
+    from dataclasses import fields
+    from .config import get_config
+
+    Config = get_config()
+
+    n = max(len(f.name) for f in fields(Config))
+
+    for f in fields(Config):
+        k = f.name
+        v = getattr(Config, f.name)
+        click.echo(f"{k:<{n}}: {v}")
+
+
+@cli.command()
+@click.option("-a", "--append", is_flag=True, help="append to file")
+@click.argument("filename")
+def config_dump(filename: str, append: bool) -> None:
+    """Dump configuration"""
+    from .utils import require_mod
+    from .config import dump_to_file
+
+    require_mod("toml")
+
+    if not dump_to_file(filename, append):
+        click.secho("can't dump configuration!", fg="red", err=True)
+        raise click.Abort()
+
+
+# @cli.command()
+# @click.option("-p", "--with-python", is_flag=True)
+# @click.option("-c", "--compile", "use_pip_compile", is_flag=True)
+# @click.argument("project_dir", required=False)
+def poetry_to_reqs(
+    project_dir: str,
+    with_python: bool,
+    use_pip_compile: bool = True,
+) -> None:
+    """Generate a requirements.txt file from pyproject.toml [**may require toml**]"""
+    import os
+    from contextlib import suppress
+    from .utils import toml_load
+
+    pyproject = "pyproject.toml"
+    if project_dir:
+        pyproject = os.path.join(project_dir, pyproject)
+    if not os.path.isfile(pyproject):
+        raise click.BadArgumentUsage("no pyproject.toml file!")
+
+    def fix(req: str) -> str:
+        if req.startswith("^"):
+            return f">={req[1:]}"
+        return req
+
+    reqs = "\n".join(
+        f"{k}{fix(v)}"
+        for k, v in sorted(
+            toml_load(pyproject)["tool"]["poetry"]["dependencies"].items(),
+        )
+        if with_python or k != "python" and isinstance(v, str)
+    )
+    if use_pip_compile:
+        try:
+            with open("requirements.in", "w", encoding="utf-8") as fp:
+                click.echo(reqs, file=fp)
+            subprocess.check_call(["pip-compile"])
+        finally:
+            with suppress(OSError):
+                os.remove("requirements.in")
+    else:
+        click.echo(reqs)

flask_nginx/config.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import os
+from dataclasses import asdict
+from dataclasses import dataclass
+from dataclasses import field
+from dataclasses import fields
+from dataclasses import replace
+from typing import IO
+
+from .utils import toml_load
+
+
+REPO = "git+https://github.com/arabidopsis/footprint.git"
+
+
+@dataclass
+class Config:
+    mailhost: str = "uwa-edu-au.mail.protection.outlook.com"
+    # mailhost: str = "antivirus.uwa.edu.au"
+    datastore: str = "//drive.irds.uwa.edu.au/sci-ms-001"
+    # directories that *might* be in the static directory
+    static_dir: str = (
+        r"img|images|js|css|media|docs|tutorials|notebooks|downloads|\.well-known"
+    )
+    # basic files that have urls such as /robots.txt /favicon.ico etc.
+    static_files: str = (
+        r"robots\.txt|crossdomain\.xml|favicon\.ico|browserconfig\.xml|humans\.txt"
+    )
+    # exclude these filenames/directories from static consideration
+    exclude: list[str] = field(default_factory=lambda: ["__pycache__"])
+    # directory to put config files: (Ubuntu, RHEL8)
+    nginx_dirs: list[str] = field(
+        default_factory=lambda: ["/etc/nginx/sites-enabled", "/etc/nginx/conf.d"],
+    )
+    arg_color: str = "yellow"  # use "none" for no color
+
+
+XConfig: Config | None = None
+
+
+def get_config() -> Config:
+    global XConfig
+    if XConfig is None:
+        XConfig = _init_config(Config())
+    return XConfig
+
+
+def _init_config(config: Config, application_dir: str = ".") -> Config:
+    project = os.path.join(application_dir, "pyproject.toml")
+    if os.path.isfile(project):
+        try:
+            d = toml_load(project)
+            if "tool" not in d:
+                return config
+            cfg = d["tool"].get("footprint")
+            if cfg is None:
+                return config
+            data = {}
+            for f in fields(config):
+                if f.name in cfg:
+                    data[f.name] = cfg[f.name]
+
+            if data:
+                config = replace(config, **data)
+
+        except ImportError:
+            pass
+        except Exception:
+            import click
+
+            click.secho(f'can\'t load "{project}"', fg="red", bold=True, err=True)
+    return config
+
+
+def dump_toml(config: Config, out: IO[str]) -> bool:
+    try:
+        import toml  # type: ignore
+
+        d = dict(tool=dict(footprint=asdict(config)))
+        toml.dump(d, out)
+        return True
+    except Exception:
+        return False
+
+
+def dump_to_file(filename: str, append: bool) -> bool:
+    config = get_config()
+    with open(filename, "a" if append else "w", encoding="utf-8") as fp:
+        return dump_toml(config, fp)

flask_nginx/core.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import os
+import re
+from contextlib import redirect_stderr
+from io import StringIO
+from os.path import abspath
+from os.path import expanduser
+from os.path import isdir
+from os.path import isfile
+from os.path import normpath
+from typing import cast
+from typing import Iterator
+from typing import NamedTuple
+from typing import TYPE_CHECKING
+
+from click import BadParameter
+from click import secho
+from click import style
+from werkzeug.routing import Rule
+
+if TYPE_CHECKING:
+    from flask import Flask
+
+
+# core ability
+
+
+class StaticFolder(NamedTuple):
+    url: str | None
+    folder: str
+    rewrite: bool
+
+
+STATIC_RULE = re.compile("^(.*)/<path:filename>$")
+
+
+def topath(path: str) -> str:
+    return normpath(abspath(expanduser(path)))
+
+
+def get_static_folders(app: Flask) -> list[StaticFolder]:  # noqa: C901
+    def get_static_folder(rule: Rule) -> str | None:
+        bound_method = app.view_functions[rule.endpoint]
+        if hasattr(bound_method, "static_folder"):
+            return bound_method.static_folder  # type: ignore
+        # __self__ is the blueprint of send_static_file method
+        if hasattr(bound_method, "__self__"):
+            bp = bound_method.__self__  # type: ignore
+            if bp.has_static_folder:
+                return bp.static_folder  # type: ignore
+        # now just a lambda :(
+        return None
+
+    def find_static(app: Flask) -> Iterator[StaticFolder]:
+        if app.has_static_folder:
+            prefix, folder = app.static_url_path, app.static_folder
+            if folder is not None and isdir(folder):
+                yield StaticFolder(
+                    prefix,
+                    topath(folder),
+                    (not folder.endswith(prefix) if prefix else False),
+                )
+        for r in app.url_map.iter_rules():
+            if not r.endpoint.endswith("static"):
+                continue
+            m = STATIC_RULE.match(r.rule)
+            if not m:
+                continue
+            rewrite = False
+            prefix = m.group(1)
+            folder = get_static_folder(r)
+            if folder is None:
+                if r.endpoint != "static":
+                    # static view_func for app is now
+                    # just a lambda.
+                    secho(
+                        f"location: can't find static folder for endpoint: {r.endpoint}",
+                        fg="red",
+                        err=True,
+                    )
+                continue
+            if not folder.endswith(prefix):
+                rewrite = True
+
+            if not isdir(folder):
+                continue
+            yield StaticFolder(prefix, topath(folder), rewrite)
+
+    return list(set(find_static(app)))
+
+
+def get_static_folders_for_app(
+    application_dir: str,
+    app: Flask | None = None,
+    prefix: str = "",
+    entrypoint: str = "app.app",
+) -> list[StaticFolder]:
+    def fixstatic(s: StaticFolder) -> StaticFolder:
+        url = prefix + (s.url or "")
+        if url and s.folder.endswith(url):
+            path = s.folder[: -len(url)]
+            return StaticFolder(url, path, False)
+        return StaticFolder(url, s.folder, s.rewrite if not prefix else True)
+
+    if app is None:
+        app = find_application(
+            application_dir,
+            get_app_entrypoint(application_dir, entrypoint),
+        )
+    return [fixstatic(s) for s in get_static_folders(app)]
+
+
+def find_application(application_dir: str, module: str) -> Flask:
+    import sys
+    from importlib import import_module
+
+    remove = False
+    if application_dir not in sys.path:
+        sys.path.append(application_dir)
+        remove = True
+    try:
+        # FIXME: we really want to run this
+        # under the virtual environment that this pertains too
+        venv = sys.prefix
+        secho(
+            f"trying to load application ({module}) using {venv}: ",
+            fg="yellow",
+            nl=False,
+            err=True,
+        )
+        with redirect_stderr(StringIO()) as stderr:
+            m = import_module(module)
+            app = m.application  # type: ignore
+        v = stderr.getvalue()
+        if v:
+            secho(f"got possible errors ...{style(v[-100:], fg='red')}", err=True)
+        else:
+            secho("ok", fg="green", err=True)
+        return cast("Flask", app)
+    except (ImportError, AttributeError) as e:
+        raise BadParameter(f"can't load application from {application_dir}: {e}") from e
+    finally:
+        if remove:
+            sys.path.remove(application_dir)
+
+
+def get_dot_env(fname: str) -> dict[str, str | None] | None:
+    try:
+        from dotenv import dotenv_values  # type: ignore
+
+        return dotenv_values(fname)
+    except ImportError:
+        import click
+
+        click.secho(
+            '".flaskenv" file detected but no python-dotenv module found',
+            fg="yellow",
+            bold=True,
+            err=True,
+        )
+        return None
+
+
+def get_app_entrypoint(application_dir: str, default: str = "app.app") -> str:
+    app = os.environ.get("FLASK_APP")
+    if app is not None:
+        return app
+    dot = os.path.join(application_dir, ".flaskenv")
+    if isfile(dot):
+        cfg = get_dot_env(dot)
+        if cfg is None:
+            return default
+        app = cfg.get("FLASK_APP")
+        if app is not None:
+            return app
+    return default

flask_nginx/irds.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import subprocess
+from getpass import getuser
+
+import click
+
+from .cli import cli
+from .systemd.systemd import systemd
+from .systemd.utils import make_args
+from .utils import get_pass
+from .utils import which
+
+
+def mount_irds(path_str: str, user: str | None = None) -> int:
+    from .config import get_config
+    from pathlib import Path
+    import os
+
+    sudo = which("sudo")
+    mount = which("mount")
+
+    path = Path(path_str).expanduser().absolute()
+    if not path.exists():
+        path.mkdir(exist_ok=True, parents=True)
+
+    datastore = path / "datastore"
+    if datastore.exists():
+        return 0
+
+    if user is None:
+        user = getuser()
+    uid = os.getuid()
+    gid = os.getgid()
+    pheme = get_pass("PHEME", f"user {user} pheme")
+    cmd = [
+        sudo,
+        mount,
+        "-t",
+        "cifs",
+        "-o",
+        f"user={user}",
+        "-o",
+        f"pass={pheme}",
+        "-o",
+        f"uid={uid},gid={gid},forceuid,forcegid",
+        get_config().datastore,
+        str(path),
+    ]
+    pmount = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    returncode = pmount.wait()
+    return returncode
+
+
+@cli.group(help=click.style("IRDS commands", fg="magenta"))
+def irds() -> None:
+    pass
+
+
+@irds.command(name="mount")
+@click.argument("directory")
+@click.argument("user", required=False)
+def mount_irds_cmd(directory: str, user: str | None) -> None:
+    """Mount IRDS datastore."""
+
+    returncode = mount_irds(directory, user=user)
+    if returncode != 0:
+        click.secho("can't mound irds", fg="red")
+        raise click.Abort()
+
+
+MOUNT_ARGS = {
+    "mount_dir": "locations of repo",
+    "user": "user to run as [default: current user]",
+    "version": "SMB version [default: 3.0]",
+    "credentials": "file containg PHEME password as a line: password={pw}"
+    " (no spaces)\nroot owned with permission 600",
+    "password": "PHEME password",
+    "drive": "IRDS drive to mount",
+}
+
+MOUNT_HELP = f"""
+Generate a systemd mount file for a IRDS.
+
+Use footprint irds systemd path/to/mount_dir ... etc.
+with the following arguments:
+
+\b
+{make_args(MOUNT_ARGS)}
+\b
+example:
+\b
+footprint irds systemd ~/irds user=00033472
+"""
+
+
+@irds.command(name="systemd", help=MOUNT_HELP)
+@click.option("-i", "--ignore-unknowns", is_flag=True, help="ignore unknown variables")
+@click.option(
+    "-c",
+    "--credentials",
+    type=click.Path(file_okay=True, dir_okay=False, exists=True),
+    help="credentials file for CIFS",
+)
+@click.option("-t", "--template", metavar="TEMPLATE_FILE", help="template file")
+@click.option("-n", "--no-check", is_flag=True, help="don't check parameters")
+@click.argument(
+    "mount_dir",
+    type=click.Path(exists=True, dir_okay=True, file_okay=False),
+    required=True,
+)
+@click.argument("params", nargs=-1)
+def systemd_mount_cmd(
+    mount_dir: str,
+    params: list[str],
+    template: str | None,
+    no_check: bool,
+    ignore_unknowns: bool,
+    credentials: str | None,
+) -> None:
+    """Generate a systemd unit file to mount IRDS.
+
+    PARAMS are key=value arguments for the template.
+    """
+    import os
+    from getpass import getpass
+
+    from .config import get_config
+
+    params = list(params)
+
+    Config = get_config()
+
+    mount_dir = mount_dir or "."
+    mount_dir = os.path.abspath(os.path.expanduser(mount_dir))
+
+    def isadir(d: str) -> str | None:
+        return None if os.path.isdir(d) else f"{d}: not a directory"
+
+    def isafile(d: str) -> str | None:
+        return None if os.path.isfile(d) else f"{d}: not a file"
+
+    se = which("systemd-escape")
+    filename = subprocess.check_output(
+        [se, "-p", "--suffix=mount", mount_dir],
+        text=True,
+    ).strip()
+
+    if credentials is not None:
+        params.append(f"credentials={os.path.expanduser(credentials)}")
+
+    systemd(
+        template or "systemd.mount",
+        mount_dir,
+        params,
+        help_args=MOUNT_ARGS,
+        check=not no_check,
+        output=filename,
+        ignore_unknowns=ignore_unknowns,
+        checks=[
+            (
+                "mount_dir",
+                lambda _, v: isadir(v),
+            ),
+            ("credentials", lambda _, v: isafile(v)),
+        ],
+        default_values=[
+            ("uid", lambda _: str(os.getuid())),
+            ("gid", lambda _: str(os.getgid())),
+            ("drive", lambda _: Config.datastore),
+            (
+                "password",
+                lambda params: (
+                    getpass(f"PHEME password for {params['user']}: ")
+                    if "credentials" not in params
+                    else None
+                ),
+            ),
+        ],
+    )
+    msg = click.style(f"footprint config systemd-install {filename}", fg="green")
+    click.echo(f'use: "{msg}" to install')

flask_nginx/logo.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+
+import click
+
+from .cli import cli
+
+
+def img2ico(png: str, out: str) -> None:
+    from PIL import Image  # type: ignore
+
+    with open(png, "rb") as fp:
+        im = Image.open(fp)
+
+        im.thumbnail((128, 128), Image.ANTIALIAS)  # type: ignore
+
+        size_tuples = [  # (256, 256),
+            (128, 128),
+            (64, 64),
+            (48, 48),
+            (32, 32),
+            (24, 24),
+            (16, 16),
+        ]
+
+        im.save(out, sizes=size_tuples)
+
+
+@cli.command()
+@click.option("-o", "--output", help="output filename")
+@click.argument(
+    "image",
+    nargs=1,
+    type=click.Path(exists=True, dir_okay=False, file_okay=True),
+)
+def img_to_ico(image: str, output: str | None) -> None:
+    "Convert a image file to an .ico file [**requires Pillow**]."
+    from .utils import require_mod
+
+    require_mod("PIL", "Pillow")
+
+    # see https://anaconda.org/conda-forge/svg2png
+    if output is None:
+        out, _ = os.path.splitext(image)
+        output = out + ".ico"
+    img2ico(image, output)

flask_nginx/mailer.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import smtplib
+from email.mime.text import MIMEText
+
+import click
+
+from .cli import cli
+
+# from email.mime.image import MIMEImage
+# from email.mime.multipart import MIMEMultipart
+
+
+def sendmail(
+    html: str,
+    you: str,
+    me: str = "footprint@uwa.edu.au",
+    mailhost: str | None = None,
+    subject: str = "footprint monitor",
+) -> None:
+    from .config import get_config
+
+    if mailhost is None:
+        mailhost = get_config().mailhost
+    msg = MIMEText(html, "html")
+
+    msg["Subject"] = subject
+    msg["From"] = me
+    msg["To"] = you
+
+    with smtplib.SMTP() as s:
+        s.connect(mailhost)
+        s.sendmail(me, [you], msg.as_string())
+
+
+@cli.command()
+@click.option("-m", "--mailhost", help="mail host to use [default from config]")
+@click.argument("email")
+@click.argument("message", nargs=-1)
+def email_test(email: str, message: list[str], mailhost: str | None) -> None:
+    """Test email setup from this host"""
+    import platform
+
+    if not message:
+        raise click.BadArgumentUsage("no message")
+
+    sendmail(
+        " ".join(message),
+        you=email,
+        mailhost=mailhost,
+        subject=f"Message from footprint on {platform.node()}",
+    )
+    click.secho("message sent!", fg="green", bold=True)