# -*- python -*-
# ex: set syntax=python:

##
# This file is part of TALER
# (C) 2016-2023 Taler Systems SA
#
# TALER is free software; you can redistribute it and/or
# modify it under the terms of the GNU Affero General Public
# License as published by the Free Software Foundation; either
# version 3, or (at your option) any later version.
#
# 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 TALER; see the file COPYING.  If not,
# see <http://www.gnu.org/licenses/>
#
# @author Florian Dold
# @author Marcello Stanisci
# @author ng0
# @author Christian Grothoff
# @author Devan Carpenter
import ast
import configparser
import glob
import os
import pathlib
import re
import subprocess

from buildbot.changes.pb import PBChangeSource
from buildbot.steps.source.git import Git
from buildbot.steps.shell import ShellCommand
from buildbot.plugins import reporters
from buildbot.plugins import schedulers
from buildbot.plugins import steps
from buildbot.plugins import util
from buildbot.process import buildstep, logobserver
from buildbot.reporters.generators.build import BuildStatusGenerator
from buildbot.worker import Worker
from twisted.internet import defer

# This is a sample buildmaster config file. It must be
# installed as 'master.cfg' in your buildmaster's base
# directory.

# This file has the following structure:
# - Globals: definition of global variables we use throughout
#   + Convenience functions: helper functions useful for many jobs
# - Jobs: actual job definitions
# - General purpose: triggers and alerts shared by various jobs
#   + general purpose notification (alerts)
#   + general purpose triggers (schedulers)
# - Actual buildbot configuration object initialization

#################################################################
######################### GLOBALS ###############################
#################################################################

# The 'workers' list defines the set of recognized workers.
# Each element is a Worker object, specifying a unique worker
# name and password.  The same worker name and password must
# be configured on the worker.
WORKERS = []

# 'services' is a list of BuildbotService items like reporter
# targets. The status of each build will be pushed to these
# targets. buildbot/reporters/*.py has a variety to choose from,
# like IRC bots.


class MessageFormatterWithStdout(reporters.MessageFormatter):
    def buildAdditionalContext(self, master, ctx):
        stdout = []
        for step in ctx["build"]["steps"]:
            for log in step["logs"]:
                all_logs = log["content"]["content"].splitlines()
                # Including only what the script printed on stdout.
                for line in all_logs:
                    if re.search("^o", line):
                        stdout.append(line[1:])
        ctx.update(dict(stdout="\n".join(stdout)))

# tipReserveEmails = reporters.MailNotifier(
#     fromaddr="buildbot@taler.net", # to be sent to a dedicate alias
#     sendToInterestedUsers=False,
#     mode=("all"),
#     builders=["check-tips-builder"], # This builder has been removed - Javisep.
#     extraRecipients=["tips@taler.net"],
#     dumpMailsToLog=True, # debug, to remove
#     messageFormatter=MessageFormatterWithStdout(
#         wantSteps=True,
#         wantLogs=True,
#         template="{{ stdout }}",
#         subject="tips availability on demo")
# )


SERVICES = []

# The 'builders' list defines the Builders, which tell Buildbot
# how to perform a build: what steps, and which workers can execute
# them.  Note that any particular build will only take place on
# one worker.
BUILDERS = []

# Configures the Schedulers, which decide how to react to incoming
# changes.
SCHEDULERS = []

# Array of builders to be scheduled every night.
NIGHTLY_TRIGGERS=[]

# Array of builders to be scheduled whenever any of the code Git repos change
CODECHANGE_TRIGGERS = []

# Array of builders to be scheduled whenever the wallet-core or
# deployment change
WALLETCHANGE_TRIGGERS = []

# Array of builder names for which build status reports should be sent
# via e-mail
EMAIL_ALERTS = []


############ Convenience functions #################

# Create a FACTORY with a deployment.git checkout as the first step.
def create_factory_with_deployment():
    f = util.BuildFactory()
    update_deployment(f)
    return f


# Convenience function that checks out a Git repository.
# First argument is the URL of the Git to clone, second
# the desired branch. Default is 'master'.
def git_step(repo, target_branch="master"):
    return Git(
        repourl=repo,
        mode="full",
        method="fresh",
        logEnviron=False,
        alwaysUseLatest=True,
        haltOnFailure=True,
        branch=target_branch
    )


# Convenience function that runs 'make check' in a
# directory of the code inside of a netjail.
def jailed_check(package, srcdirs):
    return steps.ShellSequence(
        name="Tests of " + package,
        description="Testing " + package,
        descriptionDone="Pass",
        commands=map(lambda srcdir: util.ShellArg(command=["sudo", "/usr/local/bin/netjail.sh", "/home/integrationtest/deployment/buildbot/with-postgres.sh", "bash", "-c", "'cd src/"+srcdir+" make install check'"]), srcdirs),
        env={'PATH': "${HOME}/local/bin:${PATH}"},
        workdir="../../sources/" + package
    )


# Convenience function that checks out the deployment.
def update_deployment(factory):
    factory.addStep(steps.ShellSequence(
        name="update deployment",
        description="removing old deployment and fetching fresh repository",
        descriptionDone="Deployment updated",
        commands=[
            util.ShellArg(command=["rm", "-rf", "deployment"]),
            util.ShellArg(command=["git", "clone", "git://git.taler.net/deployment"]),
        ],
        haltOnFailure=True,
        workdir="../.."
    ))


# Convenience function that builds and runs a container.
def container_add_step(HALT_ON_FAILURE,
                       WARN_ON_FAILURE,
                       CONTAINER_BUILD,
                       CONTAINER_NAME,
                       factory,
                       WORK_DIR,
                       stepName,
                       jobCmd="/workdir/ci/ci.sh",
                       containerFile="ci/Containerfile"):
    print(f"HALT_ON_FAILURE: {HALT_ON_FAILURE}, WARN_ON_FAILURE: {WARN_ON_FAILURE}, CONTAINER_BUILD: {CONTAINER_BUILD}, CONTAINER_NAME: {CONTAINER_NAME}")
    if not CONTAINER_BUILD:
        return steps.ShellSequence(
                name=stepName,
                commands=[
                    util.ShellArg(command=["sg", "docker", "-c", f"docker run --rm --user $(id -u):$(id -g) --volume {WORK_DIR}:/workdir --volume /home/container-worker/container_artifacts:/artifacts --workdir /workdir {CONTAINER_NAME} {jobCmd}"],
                                  logname='run inside container',
                                  haltOnFailure=HALT_ON_FAILURE),
                    ],
                haltOnFailure=HALT_ON_FAILURE,
                workdir=WORK_DIR
                )
    else:
        return steps.ShellSequence(
                name=stepName,
                commands=[
                    util.ShellArg(command=["sg", "docker", "-c", f"docker build -t {CONTAINER_NAME} -f {containerFile} ."],
                                  logname='build container', haltOnFailure=True),
                    util.ShellArg(command=["sg", "docker", "-c", f"docker run --rm --user $(id -u):$(id -g) --volume {WORK_DIR}:/workdir --volume /home/container-worker/container_artifacts:/artifacts --workdir /workdir {CONTAINER_NAME} {jobCmd}"],
                                  logname='run inside container',
                                  haltOnFailure=HALT_ON_FAILURE),
                    ],
                haltOnFailure=HALT_ON_FAILURE,
                workdir=WORK_DIR
                )

##################################################################
######################## JOBS ####################################
##################################################################

# For every job, we have (in this order!):
# - worker(s): hosts/users that run the job
# - factory: list of steps that define what to do
# - builder: gives the job a name and binds it to the factory and worker
# - (OPTIONAL) alerts: notifications to trigger when the job fails
#   Pre-defined: EMAIL_ALERTS
# - scheduler: rules that define when to run the job
#   Pre-defined: NIGHTLY_TRIGGERS, CODECHANGE_TRIGGERS, WALLETCHANGE_TRIGGERS

################ 1: BUILDMASTER JOB ###################################


##
# This worker restarts the buildmaster itself on
# changes to this file.
# Location: /home/buildbot-master @ taler.net
WORKERS.append(Worker("buildmaster-worker", "buildmaster-pass"))

BUILDMASTER_FACTORY = create_factory_with_deployment()
BUILDMASTER_FACTORY.addStep(
    ShellCommand(
        name="restart buildmaster",
        description="trigger buildmaster restart with new configuration",
        descriptionDone="Buildmaster updated",
        command=["systemctl", "--user", "kill", "--signal", "SIGHUP", "buildbot-master"],
        workdir="../.."
    )
)

BUILDERS.append(util.BuilderConfig(
    name="buildmaster-builder",
    workernames=["buildmaster-worker"],
    factory=BUILDMASTER_FACTORY
))

EMAIL_ALERTS.append("buildmaster-builder")

# Buildmaster is notified whenever deployment.git changes
SCHEDULERS.append(schedulers.SingleBranchScheduler(
    name="buildmaster-scheduler",
    change_filter=util.ChangeFilter(
        branch="master",
        project_re="(deployment)"
    ),
    treeStableTimer=None,
    builderNames=["buildmaster-builder"]
))


################ 2: DOCUMENTATION JOB ###################################

##
# This worker builds manuals / API docs / tutorials.
# Location: /home/docbuilder @ taler.net
WORKERS.append(Worker("doc-worker", "doc-pass"))


DOC_FACTORY = create_factory_with_deployment()
DOC_FACTORY.addStep(
    ShellCommand(
        name="fetch taler.net sources",
        description="fetching latest repositories from git.taler.net",
        descriptionDone="Taler code base updated",
        command=["./update-sources.sh", "git://git.taler.net/", "exchange", "merchant", "wallet-core", "challenger"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
    )
)

# # DOCS.GIT - GENERATE STEP 1 (create docker image) - javisep

# DOC_FACTORY = create_factory_with_deployment()
# DOC_FACTORY.addStep(
#     ShellCommand(
#         name="build image docs",
#         description="Building documentation",
#         descriptionDone="Documentation built.",
#         command=["./build.sh"],
#         workdir="/home/docbuilder/deployment/docker/docs-build",
#         env={'PATH': "${HOME}/.local/bin:${PATH}"},
#         haltOnFailure=True
#     )
# )

# # DOCS.GIT - GENERATE STEP 2 (execute docker image)  - javisep

# DOC_FACTORY.addStep(
#     ShellCommand(
#         name="run image docs",
#         description="Building documentation",
#         descriptionDone="Documentation built.",
#         command=["./run.sh"],
#         workdir="/home/docbuilder/deployment/docker/docs-build",
#         env={'PATH': "${HOME}/.local/bin:${PATH}"},
#         haltOnFailure=True
#     )
# )

# OTHER STUFF, IN THE SAME WORKER ...

DOC_FACTORY.addStep(
    steps.ShellSequence(
        name="prepare exchange",
        description="Running bootstrap and configure for exchange",
        descriptionDone="exchange ready for doxygen",
        commands=[
             util.ShellArg(command=["./bootstrap"], logname='bootstrap'),
             util.ShellArg(command=["./configure", "--enable-only-doc"], logname='configure'),
        ],
        workdir="../../sources/exchange/",
        env={'PATH': "${HOME}/.local/bin:${PATH}"},
        haltOnFailure=True,
    )
)
DOC_FACTORY.addStep(
    ShellCommand(
        name="doxygen::exchange",
        description="building exchange doxygen documentation",
        descriptionDone="doxygen on exchange finished",
        command=["make", "full" ],
        want_stderr=False,
        workdir="../../sources/exchange/doc/doxygen",
        haltOnFailure=True,
    )
)
DOC_FACTORY.addStep(
    steps.ShellSequence(
        name="prepare merchant",
        description="prepare merchant",
        descriptionDone="merchant prepared",
        commands=[
            util.ShellArg(command=["./bootstrap"], logname='bootstrap'),
            util.ShellArg(command=["./configure", "--enable-only-doc"], logname='configure'),
            util.ShellArg(command=["cp", "../exchange/doc/doxygen/taler-exchange.tag", "doc/doxygen/taler-exchange.tag"]),
        ],
        workdir="../../sources/merchant/"
    )
)
DOC_FACTORY.addStep(
    ShellCommand(
        name="doxygen::merchant",
        description="building merchant doxygen documentation",
        descriptionDone="doxygen on merchant finished",
        command=["make", "full" ],
        want_stderr=False,
        workdir="../../sources/merchant/doc/doxygen"
    )
)
## Disabled wallet doxygen job temporarily, until buildbot config refactored
# DOC_FACTORY.addStep(
#     steps.ShellSequence(
#         name="doxygen::wallet",
#         description="building wallet typescript documentation",
#         descriptionDone="typedoc on taler-wallet-core finished",
#         commands=[
#             util.ShellArg(command=["./bootstrap"], logname="bootstrap"),
#             util.ShellArg(command=["./configure"], logname="configure"),
#             util.ShellArg(command=["make"], logname="make"),
#             util.ShellArg(command=["pnpm", "install", "-W", "typedoc"], logname="pnpm"),
#             util.ShellArg(command=["./node_modules/typedoc/bin/typedoc", "--out", "dist/typedoc", "--tsconfig", "tsconfig.build.json", "packages/taler-util/src/index.ts", "packages/taler-wallet-cli/src/index.ts", "packages/taler-wallet-android/src/index.ts", "packages/taler-wallet-core/src/index.ts" ], logname="typedoc"),
#         ],
#         workdir="../../sources/wallet-core/"
#     )
# )
DOC_FACTORY.addStep(
    steps.ShellSequence(
        name="prepare challenger",
        description="Running bootstrap and configure for challenger",
        descriptionDone="challenger ready for doxygen",
        commands=[
             util.ShellArg(command=["./bootstrap"], logname='bootstrap'),
             util.ShellArg(command=["./configure", "--enable-only-doc"], logname='configure'),
        ],
        workdir="../../sources/challenger/",
        env={'PATH': "${HOME}/.local/bin:${PATH}"},
        haltOnFailure=True,
    )
)
DOC_FACTORY.addStep(
    ShellCommand(
        name="doxygen::challenger",
        description="building challenger doxygen documentation",
        descriptionDone="doxygen on challenger finished",
        command=["make", "full" ],
        want_stderr=False,
        workdir="../../sources/challenger/doc/doxygen",
        haltOnFailure=True,
    )
)


BUILDERS.append(util.BuilderConfig(
    name="doc-builder", workernames=["doc-worker"], factory=DOC_FACTORY
))

EMAIL_ALERTS.append("doc-builder")


sphinxErrorNotifier = reporters.MailNotifier(
   fromaddr="bb@taler.net",
   sendToInterestedUsers=False,
   addLogs=['build docs.stdio',],
   useTls=True,
   # notify if sphinx exits with error (command line option in Makefile turns warnings into exit 1)
   mode=('failing'),
   builders=['doc-builder',],
   extraRecipients=['sphinxerrors@taler.net']
)


# Docs run if master or stable branch of 'docs' (or deployment) changed.
SCHEDULERS.append(schedulers.SingleBranchScheduler(
    name="periodic-doc-scheduler",
    builderNames=["doc-builder"],
    change_filter=util.ChangeFilter(
        branch_re="(master|stable)", project="deployment"
    ),
    treeStableTimer=None,
))


################ 3: WEBSITE JOB ###################################

##
# This worker builds Websites: www and stage.
#
WORKERS.append(Worker("sites-worker", "sites-pass"))

SITES_FACTORY = create_factory_with_deployment()
SITES_FACTORY.addStep(
    ShellCommand(
        name="build Web sites",
        description="Building all the Taler homepages",
        descriptionDone="Sites built.",
        command=["./build-sites.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True
    )
)

BUILDERS.append(util.BuilderConfig(
    name="sites-builder", workernames=["sites-worker"], factory=SITES_FACTORY
))

EMAIL_ALERTS.append("sites-builder")


# The web page changed if 'www' changed OR if 'web' in the 'twister' repo changed:
def twister_web_page(change):
    _change = change.asDict()
    repo = _change.get("project")
    if repo in ["www", "buywith", "deployment"]:
        return True

    files = _change.get("files")
    for file in files:
        if re.search(r"web", file.get("name", "")) \
                and "twister" == repo:
            return True
    return False


# Sites are re-build whenever deployment, www buywith, or twister changes.
SCHEDULERS.append(schedulers.SingleBranchScheduler(
    name="sites-scheduler",
    builderNames=["sites-builder"],
    change_filter=util.ChangeFilter(
        branch_re="(master|stable)",
        filter_fn=twister_web_page
    ),
    treeStableTimer=None
))


################ 4: LCOV JOB ###################################

##
# This worker makes the code coverage and publishes it
# under the "lcov" Website.
WORKERS.append(Worker("lcov-worker", "lcov-pass"))

LCOV_FACTORY = create_factory_with_deployment()
LCOV_FACTORY.addStep(git_step("git://git.taler.net/wallet-core.git"))
LCOV_FACTORY.addStep(
    ShellCommand(
        name="fetch",
        description="Running yarn install of wallet",
        descriptionDone="Correctly installed",
        command=["npm", "install", "-g", "--prefix", "$HOME", "@gnu-taler/taler-wallet-cli"],
        workdir="build/",
        haltOnFailure=True,
    )
)
LCOV_FACTORY.addStep(
    ShellCommand(
        name="build",
        description="Building other Taler components",
        descriptionDone="Taler built",
        command=["./build.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
        env={'TALER_COVERAGE': "1"},
    )
)
LCOV_FACTORY.addStep(
    ShellCommand(
        name="coverage generation",
        description="running tests",
        descriptionDone="generating HTML report",
        command=["/usr/bin/sudo", "/usr/local/bin/netjail.sh", "/home/lcovworker/deployment/buildbot/coverage.sh"],
        workdir="../../deployment/buildbot",
        env={'PATH': "${HOME}/local/bin:${PATH}"}
    )
)

BUILDERS.append(util.BuilderConfig(
    name="lcov-builder",
    workernames=["lcov-worker"],
    factory=LCOV_FACTORY
))

EMAIL_ALERTS.append("lcov-builder")
NIGHTLY_TRIGGERS.append("lcov-builder")
NIGHTLY_TRIGGERS.append("taler-demo-healthcheck-builder")

################ 5: UNIT TEST JOB ###################################

##
# This worker builds everything and runs our 'make check'
# test suite against 'everything'.
WORKERS.append(Worker("checker-worker", "checker-pass"))

INTEGRATIONTEST_FACTORY = create_factory_with_deployment()
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="fetch gnunet.org sources",
        description="fetching latest deployment repositories from git.gnunet.org",
        descriptionDone="GNUnet code base updated",
        command=["./update-sources.sh", "git://git.gnunet.org/", "libmicrohttpd", "gnunet"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
    )
)
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="fetch taler.net sources",
        description="fetching latest deployment repositories from git.taler.net",
        descriptionDone="Taler code base updated",
        command=["./update-sources.sh", "git://git.taler.net/", "exchange", "merchant", "wallet-core", "sync", "bank", "twister"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
    )
)
INTEGRATIONTEST_FACTORY.addStep(git_step("git://git.taler.net/wallet-core.git"))
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="fetch",
        description="Running yarn install of wallet",
        descriptionDone="Correctly installed",
        command=["npm", "install", "-g", "--prefix", "$HOME", "@gnu-taler/taler-wallet-cli"],
        workdir="../../sources/wallet-core",
        haltOnFailure=True,
    )
)
INTEGRATIONTEST_FACTORY.addStep(
    steps.ShellSequence(
        name="fetch",
        description="Running local install of wallet",
        descriptionDone="local wallet install done",
        commands=[
            util.ShellArg(command=["./bootstrap"]),
            util.ShellArg(command=["./configure", "--prefix=$HOME/local/"]),
            util.ShellArg(command=["make install"]),
        ],
        workdir="../../sources/wallet-core",
        haltOnFailure=True,
    )
)
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="build",
        description="Building other Taler components",
        descriptionDone="Taler built",
        command=["./build.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=False
    )
)
INTEGRATIONTEST_FACTORY.addStep(jailed_check("libmicrohttpd", [
    "microhttpd",
    "testcurl",
    "testzzuf",
]))
INTEGRATIONTEST_FACTORY.addStep(jailed_check("gnunet", [
    "util",
    "pq",
    "curl",
    "json",
]))
INTEGRATIONTEST_FACTORY.addStep(jailed_check("twister", [
    "test",
]))
INTEGRATIONTEST_FACTORY.addStep(jailed_check("exchange", [
   "util",
   "curl",
   "mhd",
   "pq",
   "json",
   "bank-lib",
   "exchangedb",
   "auditordb",
   "exchange",
   "auditor",
   "lib",
   "exchange-tools",
   "testing",
   "benchmark",
]))
INTEGRATIONTEST_FACTORY.addStep(jailed_check("merchant", [
   "mustach",
   "backenddb",
   "backend",
   "lib",
   "testing",
   "merchant-tools",
]))
INTEGRATIONTEST_FACTORY.addStep(jailed_check("sync", [
    "util",
    "syncdb",
    "sync",
    "lib"
]))
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="bank check",
        description="Testing Taler Python bank",
        descriptionDone="Done",
        command=["sudo", "/usr/local/bin/netjail.sh", "/home/integrationtest/deployment/buildbot/with-postgres.sh", "make", "check"],
        workdir="../../sources/bank",
        haltOnFailure=False,
        env={'PYTHONUSERBASE': "$HOME/local" }
    )
)
INTEGRATIONTEST_FACTORY.addStep(
    ShellCommand(
        name="wallet check",
        description="Testing wallet-core",
        descriptionDone="Done",
        command=["make", "check"],
        workdir="../../sources/wallet-core",
        haltOnFailure=False
    )
)

BUILDERS.append(util.BuilderConfig(
    name="checker-builder",
    workernames=["checker-worker"],
    factory=INTEGRATIONTEST_FACTORY
))

EMAIL_ALERTS.append("checker-builder")
CODECHANGE_TRIGGERS.append("checker-builder")


################ 6: 'test.taler.net' deployment JOB ###################################

# REMOVED BY JAVIER SEPULVEDA - JANUARY 24, 2023


################ 7: 'test-auditor' deployment JOB ###################################

# REMOVED BY JAVIER SEPULVEDA - JANUARY 24, 2023


################ 8: 'demo-auditor' deployment JOB ###################################

# REMOVED BY JAVIER SEPULVEDA - JANUARY 24, 2023


################ 8: 'build wallet-core' JOB ###################################

# REMOVED BY JAVIER SEPULVEDA - JANUARY 24, 2023


################ 9: 'check links' JOB ###################################

##
# linkchecker worker checks for dead links in the Website
# Location: /home/linkchecker @ taler.net
WORKERS.append(Worker("linkchecker-worker", "linkchecker-pass"))

# linkchecker FACTORY
LINKCHECKER_FACTORY = create_factory_with_deployment()
LINKCHECKER_FACTORY.addStep(
    ShellCommand(
        name="linkchecker",
        description="Check taler.net website for broken links && Notify",
        descriptionDone="Results of wget in buildbot logs.",
        command=["/home/linkchecker/deployment/buildbot/linkchecker.sh"],
        workdir="/home/linkchecker",
        haltOnFailure=True,
    )
)

# linkchecker BUILDER
# worker at linkchecker@taler.net
BUILDERS.append(util.BuilderConfig(
    name="linkchecker-builder",
    workernames="linkchecker-worker",
    factory=LINKCHECKER_FACTORY
))

docs_generator = BuildStatusGenerator(
    mode=('change', 'problem', 'failing', 'exception',),
    builders=[
       'linkchecker-builder',
    ],
    message_formatter=reporters.MessageFormatter(
       template_type='plain',
       wantSteps=True,
       wantLogs=True
     ),
    add_logs=True
    )


SERVICES.append(reporters.MailNotifier(
    fromaddr="bb@taler.net",
    generators=[docs_generator],
    sendToInterestedUsers=False,
    useTls=True,
    extraRecipients=['linkcheck@taler.net']
))

# SERVICES.append(tipReserveEmails) 

NIGHTLY_TRIGGERS.append("linkchecker-builder")


################ 10: 'check spelling' JOB ###################################

##
# codespell worker checks for spelling mistakes in code
# Location: /home/codespell @ taler.net
WORKERS.append(Worker("codespell-worker", "codespell-pass"))

CODESPELL_FACTORY = create_factory_with_deployment()
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="clean old deployment",
        description="cleaning previous doxygen runs",
        descriptionDone="Doxygen cleaned",
        command=["rm", "-rf", "exchange/doc/doxygen/html/", "merchant/doc/doxygen/html/" ],
        workdir="/home/codespell/sources/"
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="fetch gnunet.org sources",
        description="fetching latest deployment repositories from git.gnunet.org",
        descriptionDone="GNUnet code base updated",
        command=["./update-sources.sh", "git://git.gnunet.org/", "libmicrohttpd", "gnunet"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="fetch taler.net sources",
        description="fetching latest deployment repositories from git.taler.net",
        descriptionDone="Taler code base updated",
        command=["./update-sources.sh", "git://git.taler.net/", "exchange", "merchant", "sync", "bank", "twister", "challenger"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="codespell",
        description="spell checking repositories",
        descriptionDone="Spell check complete",
        command=["/home/codespell/.local/bin/codespell", "-I", "/home/codespell/deployment/codespell/dictionary.txt", "-S", "*.bib,*.bst,*.cls,*.json,*.png,*.svg,*.wav,*.gz,*/templating/test?/**,**/auditor/*.sql,**/templating/mustach**,*.fees,*key,*.tag,*.info,*.latexmkrc,*.ecc,*.jpg,*.zkey,*.sqlite,*/contrib/hellos/**,*/vpn/tests/**,*.priv,*.file,*.tgz,*.woff,*.gif,*.odt,*.fee,*.deflate,*.dat,*.jpeg,*.eps,*.odg,*/m4/ax_lib_postgresql.m4,*/m4/libgcrypt.m4,*.rpath,config.status,ABOUT-NLS,*/doc/texinfo.tex,*.PNG,*.??.json,*.docx,*.ods,*.doc,*.docx,*.xcf,*.xlsx,*.ecc,*.ttf,*.woff2,*.eot,*.ttf,*.eot,*.mp4,*.pptx,*.epgz,*.min.js,**/*.map,**/fonts/**,*.pack.js,*.po,*.bbl,*/afl-tests/*,*/.git/**,*.pdf,*.epub,**/signing-key.asc,**/pnpm-lock.yaml,**/*.svg,**/*.cls,**/rfc.bib,**/*.bst,*/cbdc-es.tex,*/cbdc-it.tex,**/ExchangeSelection/example.ts,*/testcurl/test_tricky.c,*/i18n/strings.ts,*/src/anastasis-data.ts,**/doc/flows/main.de.tex", "bank", "exchange", "libmicrohttpd", "merchant", "sync", "twister", "challenger"],
        workdir="/home/codespell/sources/"
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="gana",
        description="fetch GANA",
        descriptionDone="GANA obtained",
        command=["./bootstrap" ],
        env={'PATH': "${HOME}/.local/bin:${PATH}"},
        workdir="/home/codespell/sources/exchange/"
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="doxygen::exchange",
        description="checking for doxygen mistakes in exchange",
        descriptionDone="doxygen on exchange finished",
        command=["/home/codespell/deployment/buildbot/doxygen.sh", "taler.doxy" ],
        workdir="/home/codespell/sources/exchange/doc/doxygen"
    )
)
CODESPELL_FACTORY.addStep(
    steps.ShellSequence(
        name="tag",
        description="prepare merchant",
        descriptionDone="directory created",
        commands=[
            util.ShellArg(command=["mkdir", "-p", "merchant/doc/doxygen/"]),
            util.ShellArg(command=["cp", "exchange/doc/doxygen/taler-exchange.tag", "merchant/doc/doxygen/taler-exchange.tag"]),
        ],
        workdir="/home/codespell/sources/"
    )
)
CODESPELL_FACTORY.addStep(
    ShellCommand(
        name="doxygen::merchant",
        description="checking for doxygen mistakes in merchant",
        descriptionDone="doxygen on merchant finished",
        command=["/home/codespell/deployment/buildbot/doxygen.sh", "taler.doxy" ],
        workdir="/home/codespell/sources/merchant/doc/doxygen"
    )
)

BUILDERS.append(util.BuilderConfig(
    name="codespell-builder",
    workernames=["codespell-worker"],
    factory=CODESPELL_FACTORY
))

EMAIL_ALERTS.append("codespell-builder")

CODECHANGE_TRIGGERS.append("codespell-builder")


################ 11: 'demo checks' JOB ###################################

# This worker is not longer in use - March 10, 2023 - @javisep

# Removed "check-tips-builder" by Javier Sepulveda - January 24,2023

##
# This worker checks that all the services run under the
# 'demo' deployment are up&running.



# WORKERS.append(Worker("demo-worker", "demo-pass"))
# DEMO_SERVICES_INTEGRATIONTEST_FACTORY = create_factory_with_deployment()
# DEMO_SERVICES_INTEGRATIONTEST_FACTORY.addStep(
#     ShellCommand(
#         name="demo services checker",
#         description="Checking demo services are online",
#         descriptionDone="Demo services are online!.",
#         command=["./checks.sh"],
#         workdir="../../deployment/buildbot",
#         haltOnFailure=True,
#         # Needed to test the 'demo' deployment.
#         env={"DEPLOYMENT": "demo"}
#     )
# )
# BUILDERS.append(util.BuilderConfig(
#     name="demo-services-checker-builder",
#     workernames="demo-worker",
#     factory=DEMO_SERVICES_INTEGRATIONTEST_FACTORY
# ))





# EMAIL_ALERTS.append("demo-services-checker-builder")

# # We check demo once per hour.
# SCHEDULERS.append(schedulers.Periodic(
#     name="demo-services-checker-scheduler",
#     periodicBuildTimer=60 * 60,  # 1 hour
#     builderNames=["demo-services-checker-builder"]
# ))


################ 12: 'demo health wallet-cli check' JOB ###################################


##
# health checks performed by wallet-cli for demo
WORKERS.append(Worker("taler-demo-healthcheck", "taler-demo-healthcheck-pass"))

TALER_DEMO_HEALTHCHECK_FACTORY = create_factory_with_deployment()
# For the moment, the health-check uses whatever wallet
# was (possibly manually) installed beforehand.  This is
# not necessarily a problem, since demo-deployments do never
# update code automatically.
TALER_DEMO_HEALTHCHECK_FACTORY.addStep(
    ShellCommand(
        name="test-withdraw-and-spend",
        description="Running wallet spend tests",
        descriptionDone="Test correctly run",
        workdir="../../deployment/buildbot",
        command=["./demo-healthchecks.sh"],
    )
)
BUILDERS.append(util.BuilderConfig(
    name="taler-demo-healthcheck-builder",
    workernames=["taler-demo-healthcheck"],
    factory=TALER_DEMO_HEALTHCHECK_FACTORY
))

################ 13: 'test health wallet-cli check' JOB ###################################

##
# health checks performed by wallet-cli for test
WORKERS.append(Worker("taler-test-healthcheck", "taler-test-healthcheck-pass"))

TALER_TEST_HEALTHCHECK_FACTORY = create_factory_with_deployment()
TALER_TEST_HEALTHCHECK_FACTORY.addStep(git_step("git://git.taler.net/wallet-core.git"))
TALER_TEST_HEALTHCHECK_FACTORY.addStep(
    ShellCommand(
        name="fetch",
        description="Running yarn install",
        descriptionDone="Correctly installed",
        command=["npm", "install", "-g", "--prefix", "$HOME", "@gnu-taler/taler-wallet-cli"],
        workdir="build/"
    )
)
TALER_TEST_HEALTHCHECK_FACTORY.addStep(
    ShellCommand(
        name="test-withdraw",
        description="Running wallet withdraw tests",
        descriptionDone="Test correctly run",
        command=["timeout", "--preserve-status", "5m", "./$HOME/bin/taler-wallet-cli", "integrationtest", "--verbose", "-b", "https://bank.test.taler.net", "-w", "TESTKUDOS:10"],
        workdir="build/",
    )
)
TALER_TEST_HEALTHCHECK_FACTORY.addStep(
    ShellCommand(
        name="test-spend",
        description="Running wallet spend tests",
        descriptionDone="Test correctly run",
        command=["timeout", "--preserve-status", "5m", "./$HOME/bin/taler-wallet-cli", "integrationtest", "--verbose", "-b", "https://bank.test.taler.net", "-s", "TESTKUDOS:4"],
        workdir="build/",
    )
)
BUILDERS.append(util.BuilderConfig(
    name="taler-test-healthcheck-builder",
    workernames=["taler-test-healthcheck"],
    factory=TALER_TEST_HEALTHCHECK_FACTORY
))


WALLETCHANGE_TRIGGERS.append("taler-test-healthcheck-builder")


################ 14: upgrade test deployment JOB ###################################

##
# testing buildbot using the "buildslavetest" user (for no specific reason except it exists)
# Location: /home/buidlslavetest @ taler.net
WORKERS.append(Worker("buildslavetest-worker", "Gei8naiyox4uuhoo"))

BUILD_FACTORY = create_factory_with_deployment()
BUILD_FACTORY.addStep(
    ShellCommand(
        name="build",
        description="Building all Taler codebase.",
        descriptionDone="Taler built.",
        command=["./build.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
        timeout=18000 # 5 hours, to avoid the Docker cleanup to timeout.
    )
)

BUILD_FACTORY.addStep(
    ShellCommand(
        name="restart services",
        description="Restart services keeping data.",
        descriptionDone="Restarting Taler.",
        command=["./restart.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
        env={
            'BRANCH': util.Property("branch"),
            # Nginx should reverse proxy to these ports.
            'TALER_DB_PORT': "16011",
            'TALER_MERCHANT_PORT': "16000",
            'TALER_EXCHANGE_PORT': "16001",
            'TALER_BLOG_PORT': "16002",
            'TALER_DONATIONS_PORT': "16003",
            'TALER_SURVEY_PORT': "16004",
            'TALER_LANDING_PORT': "16005",
            'TALER_SYNC_PORT': "16006",
            'LIBEUFIN_SANDBOX_PORT': "16007",
            'LIBEUFIN_NEXUS_PORT': "16008",
            'LIBEUFIN_FRONTEND_PORT': "16009",
            'TALER_POS_PORT': "16010"
        }
    )
)
BUILD_FACTORY.addStep(
    ShellCommand(
        name="check services correctly restarted",
        description="Checking services are correctly restarted.",
        descriptionDone="All services are correctly restarted.",
        command=["./checks.sh"],
        workdir="../../deployment/buildbot",
        haltOnFailure=True,
        env={'DEPLOYMENT': "test"}
    )
)



################ 15: Python linting JOB ###################################

# This job is noat active / complete yet!
# def lint_dispatcher(project):
#     return "./lint_%s.sh" % project

# LINT_FACTORY = util.BuildFactory()
# LINT_FACTORY.addStep(
#     ShellCommand(
#         name="Python linter",
#         description="linting Python",
#         descriptionDone="linting done",
#         command=util.Transform(lint_dispatcher, util.Property("project")),
#         workdir="../../deployment/taler-build"
#     )
# )


# This builder is NOT ACTIVE!
#BUILDERS.append(util.BuilderConfig(
#    name="lint-builder",
#    workernames=["lint-worker"],
#    factory=LINT_FACTORY
#))

# Consider adding other Python parts, like the various frontends.
# NOTE: scheduler is NOT active! (commented out below)
#SCHEDULERS.append(schedulers.SingleBranchScheduler(
#    name="lint-scheduler",
#    change_filter=util.ChangeFilter(
#        branch="master", project_re="(bank|donations|survey|blog)"
#    ),
#    treeStableTimer=None,
#    builderNames=["lint-builder"]
#))


################ 16: Selenium JOB ###################################

# This job is noat active!
SELENIUM_FACTORY = create_factory_with_deployment()
SELENIUM_FACTORY.addStep(
    ShellCommand(
        name="selenium",
        description="Headless browser test",
        descriptionDone="Test finished",
        command=["launch_selenium_test"],
        env={'PATH': "${HOME}/local/bin:/usr/lib/chromium:${PATH}"}
    )
)

#BUILDERS.append(util.BuilderConfig(
#    name="selenium-builder",
#    workernames=["selenium-worker"],
#    factory=SELENIUM_FACTORY
#))


################ 17: 'COMPILE AND CHECK - TALER ' JOB ###################################

##
# This worker compiles and checks all the Taler code 
# URL: https://git.taler.net/deployment.git/tree/docker/compile-and-check
# 01/18/2022 - Added by Javier Sepulveda

WORKERS.append(Worker("compilecheck-worker", "compilecheck-pass"))


# check-and-compile FACTORY - Step 1 - Build docker image

CHECK_AND_COMPILE_FACTORY = create_factory_with_deployment()
CHECK_AND_COMPILE_FACTORY.addStep(
    ShellCommand(
        name="Build",
        description="Build docker image",
        descriptionDone="Build Docker image: DONE",
        command=["./build.sh"],
        workdir="/home/demo/deployment/docker/compile-and-check"
    )
)


# check-and-compile FACTORY -  Step 2 - Run the docker image

CHECK_AND_COMPILE_FACTORY.addStep(
    ShellCommand(
        name="Run",
        description="Compile content & Run docker image",
        descriptionDone="Run docker image : DONE",
        command=["./run.sh"],
        workdir="/home/demo/deployment/docker/compile-and-check"
    )
)

# BUILDER check-and-compile


BUILDERS.append(util.BuilderConfig(
    name="compilecheck-builder",
    workernames=["compilecheck-worker"],
    factory=CHECK_AND_COMPILE_FACTORY
))

# Add email notification

EMAIL_ALERTS.append("compilecheck-builder")


################ 18: 'PACKAGING - DEBIAN AND UBUNTU ' JOB ###################################

##
# This worker creates Debian and Ubuntu packages 
# URL: https://git.taler.net/deployment.git/tree/packaging
# 01/23/2022 - Added by Javier Sepulveda

WORKERS.append(Worker("packaging-worker", "packaging-pass"))

# check-and-compile FACTORY - Step 1 - Build docker image

# Build debian packages

CREATE_DEBIAN_PACKAGES_FACTORY = create_factory_with_deployment()
CREATE_DEBIAN_PACKAGES_FACTORY.addStep(
    ShellCommand(
        name="Build",
        description="Build Debian packages",
        descriptionDone="Build Debian packages: DONE",
        command=["./run.sh"],
        workdir="/home/demo/deployment/packaging/debian-docker"
    )
)



# Build Ubuntu packages

CREATE_UBUNTU_PACKAGES_FACTORY = create_factory_with_deployment()
CREATE_UBUNTU_PACKAGES_FACTORY.addStep(
    ShellCommand(
        name="Build",
        description="Build Ubuntu packages",
        descriptionDone="Build Ubuntu packages: DONE",
        command=["./run.sh"],
        workdir="/home/demo/deployment/packaging/ubuntu-docker"
    )
)



# BUILDER packaging


BUILDERS.append(util.BuilderConfig(
    name="packaging-debian-builder",
    workernames=["packaging-worker"],
    factory=CREATE_DEBIAN_PACKAGES_FACTORY
))




BUILDERS.append(util.BuilderConfig(
    name="packaging-ubuntu-builder",
    workernames=["packaging-worker"],
    factory=CREATE_UBUNTU_PACKAGES_FACTORY
))

# Add email notifications - March 10, 2023, javisep

EMAIL_ALERTS.append("packaging-debian-builder")
EMAIL_ALERTS.append("packaging-ubuntu-builder")

#############################################
# 19: CONTAINER FACTORY #####################
#############################################
##
# These factories uses the standard container worker.
WORKERS.append(Worker("container-worker", "container-pass"))

#
# container_repos = ["backoffice", "wallet-core", "bank", "exchange",
#                    "merchant", "deployment", "twister", "sync",
# 		             "help", "taler-merchant-demos", "challenger"]
#


# Container Job Generator Functions
# Parse config file and save values in a dict
def ingest_job_config(configPath, jobName):
    configDict = {jobName: {}}
    print(configDict)
    ini.read_string(configPath)
    for key in ini["build"]:
        value = ini['build'][key]
        configDict[jobName][key] = value
    print(configDict)
    configDict.update(configDict)
    print(configDict)
    return configDict


# Search for configs, and ingest
def handle_job_config(jobDirPath, jobName, repoName, configPath, configExist):
    print(configPath)
    if configExist == 0:
        print(f"Ingesting Job Config: {configPath}")
        configDict = ingest_job_config(configPath, jobName)
        print(configDict)
        return configDict
    else:
        print("No job config; Using default params")
        # Set default job config parameters
        configDict = {jobName: {"HALT_ON_FAILURE": True,
                                "WARN_ON_FAILURE": False,
                                "CONTAINER_BUILD": True,
                                "CONTAINER_NAME": repoName}}
        return configDict


class GenerateStagesCommand(buildstep.ShellMixin, steps.BuildStep):

    def __init__(self, REPO_NAME, **kwargs):
        self.REPO_NAME = REPO_NAME
        kwargs = self.setupShellMixin(kwargs)
        super().__init__(**kwargs)
        self.observer = logobserver.BufferLogObserver()
        self.addLogObserver('stdio', self.observer)

    def extract_stages(self, stdout):
        stages = []
        for line in stdout.split('\n'):
            stage = str(line.strip())
            if stage:
                stages.append(stage)
        return stages

    @defer.inlineCallbacks
    def run(self):
        CONTAINER_WORKDIR = f"/home/container-worker/workspace/{self.REPO_NAME}"
        CI_JOBS_PATH = f"{CONTAINER_WORKDIR}/ci/jobs"
        # run 'ls <project_root>/ci/jobs/' to get the list of stages
        cmd = yield self.makeRemoteShellCommand()
        yield self.runCommand(cmd)
        jobDirs = []

        # if the command passes extract the list of stages
        result = cmd.results()
        if result == util.SUCCESS:
            jobDirs = self.extract_stages(self.observer.getStdout())
            print(f"this is jobDirs list: {jobDirs}")
            self.configDict = {}
            print(f"Remote cmd stdout: {self.observer.getStdout()}")
            print(f"cmd.results: {cmd.results()}")
            for stage in jobDirs:
                jobDirPath = f"{CI_JOBS_PATH}/{stage}"
                observer = logobserver.BufferLogObserver()
                self.addLogObserver('stdio', observer)
                cmd1 = yield self.makeRemoteShellCommand(
                        command=["cat", f"{jobDirPath}/config.ini"])
                yield self.runCommand(cmd1)
                print(f"cmd1.results: {cmd1.results()}")
                print(f"Second command stdout: {observer.getStdout()}")
                print(f"Current stage: {stage}")
                print(jobDirPath)
                self.configDict.update(
                        handle_job_config(
                            jobDirPath, stage, self.REPO_NAME,
                            observer.getStdout(), cmd1.results()))
                print(self.configDict)
            # create a container step for each stage and
            # add them to the build
            convstr2bool = ast.literal_eval
            self.build.addStepsAfterCurrentStep([
                container_add_step(
                    convstr2bool(
                        str(self.configDict[stage]["HALT_ON_FAILURE"])),
                    convstr2bool(
                        str(self.configDict[stage]["WARN_ON_FAILURE"])),
                    convstr2bool(
                        str(self.configDict[stage]["CONTAINER_BUILD"])),
                    self.configDict[stage]["CONTAINER_NAME"],
                    container_factory,
                    CONTAINER_WORKDIR,
                    stage,
                    f"ci/jobs/{stage}/job.sh")
                for stage in jobDirs
            ])

        return result


# List of repos to add to container factory.
container_repos = ["git.taler.net/wallet-core",
                   "git.taler.net/merchant",
                   "git.taler.net/docs",
                   "git.gnunet.org/gnunet"]

for repo in container_repos:

    # Prepare to read job configs
    ini = configparser.ConfigParser()
    ini.optionxform = str

    # Factory-wide variables
    REPO_NAME = repo.rsplit('/', 1)[1]
    REPO_URL = "https://" + repo + ".git"
    CONTAINER_WORKDIR = f"/home/container-worker/workspace/{REPO_NAME}"
    CI_JOBS_PATH = f"{CONTAINER_WORKDIR}/ci/jobs"

    # Create a factory
    container_factory = util.BuildFactory()
    container_factory.workdir = CONTAINER_WORKDIR

    # Setup workspace
    container_factory.addStep(ShellCommand(
        name="workspace",
        descriptionDone="Workspace directory check",
        command=f"test -d {CONTAINER_WORKDIR} || mkdir -p {CONTAINER_WORKDIR}",
        haltOnFailure=True,
    ))

    # Ensure repo is cloned or clean.
    # Git() will clone repo if it doesn't exist.
    # Method fresh runs 'git clean -f -f -d -x', if checkout already exists.
    # Only works with mode='full'
    # Will checkout value of "branch" property from job properties.
    # https://docs.buildbot.net/latest/manual/configuration/steps/source_git.html
    container_factory.addStep(Git(
        name="git",
        repourl=REPO_URL,
        branch=util.Interpolate('%(src::branch)s'),
        mode='full',
        method='fresh',
        haltOnFailure=True,
    ))

    container_factory.addStep(GenerateStagesCommand(
        REPO_NAME,
        name="Generate build stages",
        command=["ls", CI_JOBS_PATH],
        haltOnFailure=True))

    BUILDERS.append(util.BuilderConfig(
        name=f"{REPO_NAME}-builder",
        workernames=["container-worker"],
        factory=container_factory
    ))

    # Only enable this scheduler for debugging!
    # Will run builders with 1 minute of waiting inbetween builds
    # SCHEDULERS.append(schedulers.Periodic(
    #     name=f"{REPO_NAME}-minutely",
    #     builderNames=[f"{REPO_NAME}-builder"],
    #     periodicBuildTimer=60
    #     ))

    # Buildmaster is notified whenever deployment.git changes
    SCHEDULERS.append(schedulers.SingleBranchScheduler(
        name=f"{REPO_NAME}-container-scheduler",
        change_filter=util.ChangeFilter(
            branch_re='.*',
            project_re=f"({REPO_NAME})"
        ),
        treeStableTimer=None,
        builderNames=[f"{REPO_NAME}-builder"]
    ))

# TODO: TBD
# EMAIL_ALERTS.append("container-builder")



################ 99: debug stuff JOB ###################################

# This does nothing, just a starting point for a factory.
DEBUG_FACTORY = util.BuildFactory()
DEBUG_FACTORY.addStep(
    ShellCommand(
        name="echo debug",
        description="just echoing a word",
        descriptionDone="builder responded",
        command=["echo", "I'm here!"]
    )
)


##################################################################
#################### General purpose #############################
##################################################################

# Compute array of the names of all of our builders
BUILDER_LIST = map(lambda builder: builder.name, BUILDERS)

####### GENERAL PURPOSE BUILDBOT SERVICES #######################

SERVICES.append(reporters.IRC(
    "irc.eu.libera.net",
    "taler-bb",
    useColors=False,
    channels=[{
        "channel": "#taler"
    }],
    password="taler-bb-pass19",
    notify_events={
        'exception': 1,
        'successToFailure': 1,
        'failureToSuccess': 1
    }
))

SERVICES.append(reporters.MailNotifier(
    fromaddr="testbuild@taler.net",
    # notify from pass to fail, and viceversa.
    generators=[BuildStatusGenerator(
        mode=('change','problem','failing','exception',),
        builders=EMAIL_ALERTS,
        message_formatter=reporters.MessageFormatter(
            template_type='plain',
            wantSteps=True,
            wantLogs=True
        ),
        add_logs=True,
    )],
    sendToInterestedUsers=False,
    extraRecipients=["buildfailures@taler.net"]
))


############# GENERAL PURPOSE SCHEDULERS ##########################

# Workers that are done on wallet or deployment changes to master
SCHEDULERS.append(schedulers.SingleBranchScheduler(
    name="taler-healthcheck-scheduler",
    change_filter=util.ChangeFilter(
        branch="master",
        project_re="(wallet|deployment)"
    ),
    treeStableTimer=None,
    builderNames=WALLETCHANGE_TRIGGERS
))

SCHEDULERS.append(schedulers.SingleBranchScheduler(
    name="all-scheduler",
    change_filter=util.ChangeFilter(
        branch_re="(master|stable)",
        project_re="(backoffice|wallet-core|bank|exchange|"
        "merchant|deployment|twister|sync|"
        "help|taler-merchant-demos)"
    ),
    treeStableTimer=None,
    builderNames=CODECHANGE_TRIGGERS
))

# Scheduler for all nightly builds.
SCHEDULERS.append(schedulers.Nightly(
    name="nightly-scheduler",
    builderNames=list(NIGHTLY_TRIGGERS),
    branch="master",
    hour=6,
    minute=0
))

# Provide "force" button in the web UI.
SCHEDULERS.append(schedulers.ForceScheduler(
    name="force-scheduler",
    builderNames=list(BUILDER_LIST)
))


#########################################################
####### Actual configuation initialization ##############
#########################################################

# This is the dictionary that the buildmaster pays attention to.  We also use
# a shorter alias to save typing.
c = BuildmasterConfig = {}
c["workers"] = WORKERS
c["builders"] = BUILDERS
c["schedulers"] = SCHEDULERS
c["services"] = SERVICES

# Silence warning and allow very basic phoning home.
c["buildbotNetUsageData"] = "basic"

c["title"] = "GNU Taler"
c["titleURL"] = "https://taler.net"

# This specifies what database buildbot uses to store its
# state.  You can leave  this at its default for all but the
# largest installations.
c["db"] = {
    "db_url": "sqlite:///state.sqlite",
}

# the 'change_source' setting tells the buildmaster how it should
# find out about source code changes.
c["change_source"] = [PBChangeSource(user="allcs", passwd="allcs")]

# 'protocols' contains information about protocols which master
# will use for communicating with workers. You must define at
# least 'port' option that workers could connect to your master
# with this protocol. 'port' must match the value configured into
# the workers (with their --master option)
c["protocols"] = {"pb": {"port": "tcp:9989:interface=127.0.0.1"}}

# We use nginx to expose the BB under this URL.
c["buildbotURL"] = "https://buildbot.taler.net/"


# minimalistic config to activate new web UI
# -- formerly commented out as not packaged properly in Debian and others, see
# https://bugzilla.redhat.com/show_bug.cgi?id=1557687
c["www"] = {
    "port": 8010,
    "default_page": 'waterfall',
    "plugins": {
        "waterfall_view": True,
        "console_view": True,
        "grid_view": True,
    },
    "allowed_origins": ["https://*.taler.net"],
    "avatar_methods": [],
}