path: root/bin/WIP/taler-local

#!/usr/bin/env python3

# This file is part of GNU Taler.
#
# GNU Taler is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# GNU Taler is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Taler.  If not, see <https://www.gnu.org/licenses/>.

import click
import types
import os
import sys
import os.path
import subprocess
import time
import random
from os import listdir
from os.path import isdir, join
from pathlib import Path
from dataclasses import dataclass
from typing import List, Callable
from shutil import copy
from taler_urls import get_urls
from string import ascii_letters, ascii_uppercase

@dataclass
class Repo:
    name: str
    url: str
    deps: List[str]
    builder: Callable[["Repo", Path], None]

@click.group()
def cli():
    pass

def split_repos_list(repos):
    return [repo for repo in repos.split(",") if repo != ""]

def update_checkout(r: Repo, p: Path):
    """Clean the repository's working directory and
    update it to the match the latest version of the upstream branch
    that we are tracking."""
    subprocess.run(["git", "-C", str(p), "clean", "-fdx"], check=True)
    subprocess.run(["git", "-C", str(p), "fetch"], check=True)
    subprocess.run(["git", "-C", str(p), "reset"], check=True)
    res = subprocess.run(
        [
            "git",
            "-C",
            str(p),
            "rev-parse",
            "--abbrev-ref",
            "--symbolic-full-name",
            "@{u}",
        ],
        stderr=subprocess.DEVNULL,
        stdout=subprocess.PIPE,
        encoding="utf-8",
    )
    if res.returncode != 0:
        ref = "HEAD"
    else:
        ref = res.stdout.strip("\n ")
    print(f"resetting {r.name} to ref {ref}")
    subprocess.run(["git", "-C", str(p), "reset", "--hard", ref], check=True)


def default_configure(*extra):
    pfx = Path.home() / ".local"
    extra_list = list(extra)
    subprocess.run(["./configure", f"--prefix={pfx}"] + extra_list, check=True)

def pyconfigure(*extra):
    """For python programs, --prefix doesn't work."""
    subprocess.run(["./configure"] + list(extra), check=True)

def build_libeufin(r: Repo, p: Path):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    default_configure()
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_libmicrohttpd(r: Repo, p: Path):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    # Debian gnutls packages are too old ...
    default_configure("--with-gnutls=/usr/local")
    subprocess.run(["make"], check=True)
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_gnunet(r: Repo, p: Path):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "--enable-logging=verbose",
        f"--with-microhttpd={pfx}",
        "--disable-documentation",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_exchange(r: Repo, p: Path):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "CFLAGS=-ggdb -O0",
        "--enable-logging=verbose",
        f"--with-microhttpd={pfx}",
        f"--with-gnunet={pfx}",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_wallet(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    default_configure()
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_twister(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "CFLAGS=-ggdb -O0",
        "--enable-logging=verbose",
        f"--with-exchange={pfx}",
        f"--with-gnunet={pfx}",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()


def build_merchant(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "CFLAGS=-ggdb -O0",
        "--enable-logging=verbose",
        f"--with-microhttpd={pfx}",
        f"--with-exchange={pfx}",
        f"--with-gnunet={pfx}",
        "--disable-doc",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_sync(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "CFLAGS=-ggdb -O0",
        "--enable-logging=verbose",
        f"--with-microhttpd={pfx}",
        f"--with-exchange={pfx}",
        f"--with-merchant={pfx}",
        f"--with-gnunet={pfx}",
        "--disable-doc",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()


def build_anastasis(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"], check=True)
    pfx = Path.home() / ".local"
    default_configure(
        "CFLAGS=-ggdb -O0",
        "--enable-logging=verbose",
        f"--with-microhttpd={pfx}",
        f"--with-exchange={pfx}",
        f"--with-merchant={pfx}",
        f"--with-gnunet={pfx}",
        "--disable-doc",
    )
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()


def build_demos(r, p):
    update_checkout(r, p)
    pfx = Path.home() / ".local"
    pyconfigure()
    subprocess.run(["make", "install"], check=True)
    (p / "taler-buildstamp").touch()

def build_backoffice(r, p):
    update_checkout(r, p)
    subprocess.run(["./bootstrap"])
    subprocess.run(["./configure"])
    subprocess.run(["make", "build-single"])
    (p / "taler-buildstamp").touch()

repos = {
    "libmicrohttpd": Repo(
        "libmicrohttpd",
        "git://git.gnunet.org/libmicrohttpd.git",
        [],
        build_libmicrohttpd,
    ),
    "gnunet": Repo(
        "gnunet",
        "git://git.gnunet.org/gnunet.git",
        ["libmicrohttpd"],
        build_gnunet
    ),
    "exchange": Repo(
        "exchange",
        "git://git.taler.net/exchange",
        ["gnunet", "libmicrohttpd"],
        build_exchange,
    ),
    "merchant": Repo(
        "merchant",
        "git://git.taler.net/merchant",
        ["exchange","libmicrohttpd","gnunet"],
        build_merchant,
    ),
    "sync": Repo(
       "sync",
       "git://git.taler.net/sync",
       ["exchange",
        "merchant",
        "gnunet",
        "libmicrohttpd"],
       build_sync,
   ),
    "anastasis": Repo(
       "anastasis",
       "git://git.taler.net/anastasis",
       ["exchange",
        "merchant",
        "libmicrohttpd",
        "gnunet"],
       build_anastasis,
    ),
    "wallet-core": Repo(
        "wallet-core",
        "git://git.taler.net/wallet-core",
        [],
        build_wallet,
    ),
    "libeufin": Repo(
        "libeufin",
        "git://git.taler.net/libeufin.git",
        [],
        build_libeufin,
    ),
    "taler-merchant-demos": Repo(
        "taler-merchant-demos",
        "git://git.taler.net/taler-merchant-demos",
        [],
        build_demos,
    ),
    "twister": Repo(
        "twister",
        "git://git.taler.net/twister",
        ["gnunet", "libmicrohttpd"],
        build_twister,
    ),
}

def get_repos_names() -> List[str]:
    r_dir = Path.home() / ".taler-sources"
    return [el for el in listdir(r_dir) if isdir(join(r_dir, el)) and repos.get(el)]

# Get the installed repositories from the sources directory.
def load_repos(reposNames) -> List[Repo]:
    return [repos.get(r) for r in reposNames if repos.get(r)]

def update_repos(repos: List[Repo]) -> None:
    for r in repos:
        r_dir = Path.home() / ".taler-sources" / r.name
        subprocess.run(["git", "-C", str(r_dir), "fetch"], check=True)
        res = subprocess.run(
            ["git", "-C", str(r_dir), "status", "-sb"],
            check=True,
            stdout=subprocess.PIPE,
            encoding="utf-8",
        )
        if "behind" in res.stdout:
            print(f"new commits in {r}")
            s = r_dir / "taler-buildstamp"
            if s.exists():
                s.unlink()

def get_stale_repos(repos: List[Repo]) -> List[Repo]:
    timestamps = {}
    stale = []
    for r in repos:
        r_dir = Path.home() / ".taler-sources" / r.name
        s = r_dir / "taler-buildstamp"
        if not s.exists():
            timestamps[r.name] = time.time()
            stale.append(r)
        ts = timestamps[r.name] = s.stat().st_mtime
        for dep in r.deps:
            if timestamps[dep] > ts:
                stale.append(r)
                break
    return stale

@cli.command()
@click.option(
    "--without-repos", metavar="WITHOUT REPOS",
    help="WITHOUT REPOS is a unspaced and comma-separated list \
of the repositories to _exclude_ from compilation",
    default="")
def build(without_repos) -> None:
    """Build the deployment from source."""
    exclude = split_repos_list(without_repos)
    # Get the repositories names from the source directory
    repos_names = get_repos_names()
    # Reorder the list of repositories so that the
    # most fundamental dependecies appear left-most.
    repos_keys = repos.keys() # Has the precedence rules.
    sorted_repos = sorted(
        set(repos_keys).intersection(repos_names),
        key=lambda x: list(repos_keys).index(x)
    )
    target_repos = load_repos(sorted_repos) # Get Repo objects
    update_repos(target_repos)
    stale = get_stale_repos(target_repos)
    print(f"found stale repos: {[r.name for r in stale]}")
    for r in stale:
        if r.name in exclude:
            print(f"not building: {r.name}")
            continue
        # Warn, if a dependency is not being built:
        diff = set(r.deps) - set(repos_names)
        if len(diff) > 0:
            print(f"WARNING: those dependencies are not being built: {diff}")
        p = Path.home() / ".taler-sources" / r.name
        os.chdir(str(p))
        r.builder(r, p)

# Download the repository.
def checkout_repos(repos: List[Repo]):
    if len(repos) == 0:
        print("No repositories can be checked out.  Spelled correctly?")
        return
    home = Path.home()
    sources = home / ".taler-sources"
    for r in repos:
        r_dir = home / ".taler-sources" / r.name
        if not r_dir.exists():
            r_dir.mkdir(parents=True, exist_ok=True)
            subprocess.run(["git", "-C", str(sources), "clone", r.url], check=True)

@cli.command()
@click.option(
    "--repos", "-r",
    metavar="REPOS",
    help="REPOS is a unspaced and comma-separated list of the repositories to clone.",
    default="libmicrohttpd,gnunet,exchange,merchant,wallet-core,taler-merchant-demos,sync,anastasis,libeufin",
    show_default=True,
)
def bootstrap(repos) -> None:

    """Clone all the specified repositories."""

    home = Path.home()
    reposList = split_repos_list(repos)    
    checkout_repos(load_repos(reposList))

if __name__ == "__main__":
    cli()