dev

#!/usr/bin/env python3
"""
Various tools for interacting with a bmon deployment; works both locally and
in production.

Should run `bmon-config` before using this tool.

The difference between `bmon-util` and this file is that the former is meant to be
run from within a docker container, whereas this is run on the host.
"""

import json
import time
import sys
import subprocess
import functools
import os

import clii

from bmon_infra import infra, config
from fscm import p, RunReturn

cli = clii.App()

os.environ["PYTHONUNBUFFERED"] = "1"


def sh(cmd, **kwargs):
    return subprocess.run(cmd, shell=True, **kwargs)


@functools.cache
def getenv():
    return config.get_env_object()


def is_dev() -> bool:
    """True if we're in the dev environment."""
    return getenv().BMON_ENV == "dev"


def is_regtest() -> bool:
    """True if we're running on regtest."""
    return (rpcport := getenv().BITCOIN_RPC_PORT) and int(rpcport) == "18443"


def brpc(cmd, **kwargs):
    """Run a bitcoin RPC command."""
    flags = "-regtest" if is_regtest() else ""

    return sh(
        "docker-compose exec bitcoind "
        f"bitcoin-cli {flags} -datadir=/bitcoin/data {cmd}",
        **kwargs,
    )


def dev_only(func):
    """Decorator that enforces a command is run only in the dev environment."""

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not is_dev():
            print("Shouldn't be running {func} outside of a dev environment")
            sys.exit(1)
        else:
            return func(*args, **kwargs)

    return wrapper


@cli.cmd
def bitcoinrpc(*cmd):
    return brpc(" ".join(cmd))


@cli.cmd
def bitcoind_wait_for_synced():
    """
    Wait until bitcoind's tip is reasonably current.

    This is helpful for bootstrapping new monited bitcoind instances without
    generating a bunch of spurious data.
    """
    tries = 12
    backoff_secs = 2
    is_synced = False
    got = {}
    i = 0

    while tries and not is_synced:
        try:
            got = json.loads(
                brpc("getblockchaininfo", text=True, capture_output=True).stdout
            )
        except Exception as e:
            print(f"exception getting verification progress: {e}")
            tries -= 1
            time.sleep(backoff_secs)
            if backoff_secs < 120:
                backoff_secs *= 2
        else:
            is_synced = float(got["verificationprogress"]) > 0.9999
            time.sleep(1)
            tries = 12

            if i % 40 == 0:
                print(f"At height {got['blocks']} ({got['verificationprogress']})", flush=True)

            i += 1

    if not is_synced:
        print("Failed to sync!")
        sys.exit(1)

    print(f"Synced to height: {got['blocks']}")


@cli.cmd
@dev_only
def generateblock():
    wallets = json.loads(brpc("listwallets", capture_output=True).stdout)
    if "test" not in wallets:
        brpc("createwallet test false false '' false true true")

    if '"test"' not in brpc("getwalletinfo", capture_output=True, text=True).stdout:
        brpc("loadwallet test")
    sh(
        "docker-compose exec bitcoind bitcoin-cli -regtest -datadir=/bitcoin/data -generate"
    )


@cli.cmd
def managepy(*cmd):
    sh(f"docker-compose run --rm shell python manage.py {' '.join(cmd)}")


@cli.cmd
def shell():
    managepy("shell")


@cli.cmd
@dev_only
def reup(
    service: str = "",
    rebuild_docker: bool = False,
    logs: bool = False,
    data: bool = False,
):
    sh(f"docker-compose down {service} ; docker-compose rm -f {service} ")
    if rebuild_docker:
        sh("docker-compose build")

    if data:
        cleardata()

    sh("bmon-config")
    env = config.get_env_object()
    p(env.BITCOIND_VERSION_PATH).contents(infra.get_bitcoind_version())

    sh("docker-compose up -d db")
    managepy("migrate")
    sh(f"docker-compose up -d {service}")

    if logs:
        sh(f"docker-compose logs -f {service}")


@cli.cmd
def watchlogs(others: str = ""):
    """Tail interesting logs."""
    sh(
        "docker-compose logs -f bitcoind server-task-worker "
        f"bitcoind-task-worker bitcoind-watcher bitcoind-mempool-worker {others}"
    )


@cli.cmd
@dev_only
def cleardata():
    sh("sudo rm -fr services/dev/*")
    sh("bmon-config")


def _testrun(cmd: str) -> bool:
    return sh(
        f"docker-compose run --rm -e RUN_DB_MIGRATIONS= test -- bash -c '{cmd}'",
        env={'BMON_BITCOIND_PORT': '8555', 
             'BMON_BITCOIND_RPC_PORT': '8554', 
             'BMON_REDIS_OPTIONS': '',
             **os.environ},
    ).returncode == 0


@cli.cmd
@dev_only
def test(run_mypy: bool = False):
    """Run automated tests."""

    flake8_command = "flake8 %s --count --show-source --statistics"

    bmon_failed = not _testrun(flake8_command % 'bmon/')
    infra_failed = not _testrun(flake8_command % 'infra/')

    if run_mypy:
        mypy()

    test_failed = not _testrun("pytest -vv bmon")

    if bmon_failed or infra_failed:
        sys.exit(1)
    if test_failed:
        sys.exit(2)


@cli.cmd
@dev_only
def mypy():
    bmon_failed = not _testrun("mypy bmon/")
    infra_failed = not _testrun("mypy --exclude infra/build infra/")

    if bmon_failed or infra_failed:
        sys.exit(3)


@cli.cmd
@dev_only
def watchjs():
    """Watch the frontend javascript and rebuild as necessary."""
    sh("docker-compose run --rm js yarn run start")


@cli.cmd
def sql_shell(db_host: str = "localhost"):
    e = getenv()
    db = f"postgres://bmon:{e.DB_PASSWORD}@{db_host}:5432/bmon"
    print(f"Connecting to {db}")
    sh(f"pgcli {db}")


@cli.cmd
def pgcli():
    sql_shell()


if __name__ == "__main__":
    cli.run()