Tiltfile

# This file is used for local development with tilt from https://tilt.dev/ in order to stand up the faf k8s stack from scratch

config.define_string("windows-bash-path", args=False, usage="Path to bash.exe for windows")
config.define_string("default-pull-policy", args=False, usage="Pull policy to use for containers")
config.define_string("host-ip", args=False, usage="IP Address of the host to enable redirection to local services")
config.define_string("hostname", args=False, usage="Accessible name of the host to enable redirection to local services")
config.define_string("faf-data-dir", args=False, usage="Directory where the FAF Data lives normally C:/ProgramData/FAForever on Windows or ~/.faforever on Linux")
config.define_string("base-domain", args=False, usage="Base Domain to use for all faf services. Defaults to faforever.localhost")
config.define_string_list("local", args=False, usage="Names of services that you intend to run locally")
config.define_string_list("run", args=False, usage="Names of applciatioons that you intend to run")
cfg = config.parse()
is_ci = os.getenv("CI", False)
windows_bash_path = cfg.get("windows-bash-path", "C:\\Program Files\\Git\\bin\\bash.exe")
host_ip = cfg.get("host-ip", "")
local_services = cfg.get("local", [])
applications = cfg.get("run", [])
base_domain = cfg.get("base-domain", "faforever.localhost")

specified_services = applications
if (specified_services):
    specified_services = specified_services + ["populate-featured-mod-files", "create-hosts-file-content", "populate-db"]

config.set_enabled_resources(specified_services)

data_relative_path = ".local-data"
if os.name == "nt":
    faf_data_dir = cfg.get("faf-data-dir", "C:/ProgramData/FAForever")
    if not os.path.exists(windows_bash_path):
        fail("Windows users need to supply a valid path to a bash executable")

    data_absolute_path = "//data/" + data_relative_path
    if k8s_context() == "docker-desktop":
        hostname = cfg.get("hostname", "host.docker.internal")
    elif k8s_context() == "minikube" or k8s_context() == "kind-kind":
        hostname = cfg.get("hostname", "")

else:
    faf_data_dir = cfg.get("faf-data-dir", "~/.faforever")
    hostname = cfg.get("hostname", "")
    data_absolute_path = os.path.join(os.getcwd(), data_relative_path)

host_details = ["hostIP="+host_ip, "hostname="+hostname]

def as_windows_command(command):
    if type(command) == "list":
        return [windows_bash_path, "-c"] + [" ".join(command)]
    else:
        fail("Unknown command type")

def agnostic_local_resource(name, cmd, **kwargs):
    local_resource(name=name, cmd=cmd, cmd_bat=as_windows_command(cmd), **kwargs)

def agnostic_local(cmd):
    local(command=cmd, command_bat=as_windows_command(cmd))

def patch_config(yaml, config_name, config):
    objects = decode_yaml_stream(yaml)
    for object in objects:
        if object["kind"] == "ConfigMap" and object["metadata"]["name"] == config_name:
            object["data"].update(config)
    
    return encode_yaml_stream(objects)

def keep_objects_of_kind(yaml, kinds):
    objects = decode_yaml_stream(yaml)
    return encode_yaml_stream([object for object in objects if object["kind"] in kinds])

def remove_init_container(yaml):
    objects = decode_yaml_stream(yaml)
    for object in objects:
        if "spec" in object:
            spec = object["spec"]
            if "template" in spec:
                template = spec["template"]
                if "spec" in template and "initContainers" in template["spec"]:
                    template["spec"].pop("initContainers", None)

    return encode_yaml_stream(objects)

def cronjob_to_job(yaml):
    objects = decode_yaml_stream(yaml)
    for object in objects:
        if object["kind"] == "CronJob":
            object["kind"] = "Job"
            spec = object["spec"]
            spec.pop("suspend", None)
            spec.pop("schedule", None)
            job_template = spec.pop("jobTemplate", {"spec": {"template": {}}})
            spec["template"] = job_template["spec"]["template"]

    return encode_yaml_stream(objects)

def helm_with_build_cache(chart, namespace="", values=[], set=[], specifier = ""):
    cache_dir = ".helm-cache"
    
    chart_name = chart.split("/")[-1]
    chart_resource = chart.replace("/", "-") + "-" + specifier
    chart_cache_path = os.path.join(cache_dir, chart, specifier).replace("\\", "/")
    cached_yaml = os.path.join(chart_cache_path, "yaml")
    value_flags = [fragment for value in values for fragment in ("--values", value)]
    set_flags = [fragment for set_value in set for fragment in ("--set", set_value)]
    command = ["./tilt/scripts/helm-with-cache.sh", chart_cache_path, chart_name, chart, "--include-crds", "--skip-tests"]
    if namespace:
        command.extend(["--namespace", namespace])
    command.extend(value_flags)
    command.extend(set_flags)
    command.extend(["--set", "baseDomain=" + base_domain])

    if is_ci:
        agnostic_local(command)
        objects = read_yaml_stream(cached_yaml)
        if not objects:
            fail("No objects found for chart " + chart)
    else:
        deps = [chart]
        deps.extend(values)
        agnostic_local_resource(name=chart_resource + "-helm", cmd=command, labels=["helm"], deps=deps, allow_parallel=True)

        if not os.path.exists(cached_yaml):
            agnostic_local(command)

        objects = read_yaml_stream(cached_yaml)
        if not objects:
            agnostic_local(command)
            objects = read_yaml_stream(cached_yaml)

    watch_file(cached_yaml)

    if namespace:
        for object in objects:
            if "namespace" not in object["metadata"]:
                object["metadata"]["namespace"] = namespace 
    
    default_pull_policy = cfg.get("default-pull-policy", "IfNotPresent")

    for object in objects:
        spec = object.get("spec", {})
        template_spec = spec.get("template", {}).get("spec", {})
        containers = template_spec.get("containers", []) 
        for container in containers:
            container["imagePullPolicy"] = default_pull_policy
            container["resources"] = {}
        init_containers = template_spec.get("initContainers", []) 
        for init_container in init_containers:
            init_container["imagePullPolicy"] = default_pull_policy
        job_template_spec = object.get("spec", {}).get("jobTemplate", {}).get("spec", {}).get("template", {}).get("spec", {})
        job_template_containers = job_template_spec.get("containers", []) 
        for container in job_template_containers:
            container["imagePullPolicy"] = default_pull_policy
        job_template_init_containers = job_template_spec.get("initContainers", []) 
        for init_container in job_template_init_containers:
            init_container["imagePullPolicy"] = default_pull_policy
        if "entryPoints" in spec:
            entryPoints = spec["entryPoints"]
            if "websecure" in entryPoints:
                entryPoints.append("web")
        if not is_ci and (containers or job_template_containers):
            metadata = object["metadata"]
            if "annotations" not in metadata or not metadata["annotations"]:
                metadata["annotations"] = {}

            metadata["annotations"]["reloader.stakater.com/auto"] = "true"

    return encode_yaml_stream(objects)

def to_hostpath_storage(yaml):
    objects = decode_yaml_stream(yaml)
    for object in objects:
        if object["kind"] == "PersistentVolume":
            object["spec"].pop("nodeAffinity", None)
            localpath_spec = object["spec"].pop("local", {"path": ""})
            
            object["spec"]["hostPath"] = localpath_spec
            object["spec"]["hostPath"]["type"] = "DirectoryOrCreate"
            object["spec"]["accessModes"] = ["ReadWriteMany"]
        if object["kind"] == "PersistentVolumeClaim":
            object["spec"]["accessModes"] = ["ReadWriteMany"]
            
    return encode_yaml_stream(objects)

def proxy_local_service_if_set(service_name, service_chart, service_namespace, additional_values=[], config_patch={}, service_deps=[], service_labels=[], service_links=[]):
    all_service_deps = []
    all_service_deps.extend(service_deps)
    service_objects = []

    service_yaml = helm_with_build_cache(service_chart, namespace=service_namespace, values=["config/local.yaml"] + additional_values)
    service_config_yaml, service_yaml = filter_yaml(service_yaml, kind="ConfigMap|Secret")
    service_config_yaml = patch_config(yaml=service_config_yaml, config_name=service_name, config=config_patch)
    if (service_config_yaml):
        k8s_yaml(service_config_yaml)
        config_objects = []
        for object in decode_yaml_stream(service_config_yaml):
            config_objects.append(object["metadata"]["name"] + ":" + object["kind"].lower())
        service_config_name = service_name+"-config"
        k8s_resource(new_name=service_config_name, objects=config_objects, labels=service_labels)
        all_service_deps.append(service_config_name)

    service_traefik_yaml, service_yaml = filter_yaml(service_yaml, api_version="traefik.io/v1alpha1")
    if (service_traefik_yaml):
        k8s_yaml(service_traefik_yaml)
        
        for object in decode_yaml_stream(service_traefik_yaml):
                service_objects.append(object["metadata"]["name"] + ":" + object["kind"].lower())
        all_service_deps.append("traefik")

    if (service_name in local_services):
        service_ingress_details = extract_ingress_details(service_traefik_yaml)
        if not service_ingress_details:
            service_ingress_details = ["name="+service_name]
        service_proxy_yaml = helm_with_build_cache("tilt/helm/host-proxy", specifier=service_name, namespace=service_namespace, values=["config/local.yaml"], set=host_details+service_ingress_details)
        k8s_yaml(service_proxy_yaml)
        for object in decode_yaml_stream(service_proxy_yaml):
            service_objects.append(object["metadata"]["name"] + ":" + object["kind"].lower())
        k8s_resource(new_name=service_name, objects=service_objects, resource_deps=all_service_deps, labels=service_labels, links=service_links, pod_readiness="ignore")
    elif (service_yaml):
        if service_name == "faf-icebreaker" or service_name == "faf-player-service":
            service_yaml = remove_init_container(service_yaml)

        k8s_yaml(service_yaml)
        k8s_resource(workload=service_name, objects=service_objects, resource_deps=all_service_deps, labels=service_labels, links=service_links)


def extract_ingress_details(yaml):
    objects = decode_yaml_stream(yaml)
    for object in objects:
        if object["kind"] == "IngressRoute":
            routes = object["spec"]["routes"]
            service = routes[0]["services"][0]
            return ["port=" + str(service["port"]), "name=" + service["name"]]
    return []

agnostic_local_resource("create-hosts-file-content", cmd=["./tilt/scripts/print-hosts.sh"], labels=["core"], auto_init=False, trigger_mode=TRIGGER_MODE_MANUAL, allow_parallel=True)
agnostic_local_resource("populate-featured-mod-files", cmd=["./tilt/scripts/update-faf-featured-mod.sh", faf_data_dir], labels=["database"], resource_deps=["faf-db-migrations"], auto_init=False, trigger_mode=TRIGGER_MODE_MANUAL, allow_parallel=True)
agnostic_local_resource("populate-db", cmd=["./tilt/scripts/populate-database.sh"], labels=["database"], resource_deps=["faf-db-migrations"], auto_init=False, trigger_mode=TRIGGER_MODE_MANUAL, allow_parallel=True)

k8s_yaml("cluster/namespaces.yaml")
k8s_yaml(helm_with_build_cache("infra/clusterroles", namespace="faf-infra", values=["config/local.yaml"]))
k8s_resource(new_name="namespaces", objects=["faf-infra:namespace", "faf-apps:namespace", "faf-ops:namespace", "traefik:namespace", "replay-mounter:namespace"], labels=["core"])
k8s_resource(new_name="clusterroles", objects=["read-cm-secrets:clusterrole"], resource_deps=["namespaces"], labels=["core"])
k8s_resource(new_name="init-apps", objects=["init-apps:serviceaccount:faf-infra", "init-apps:serviceaccount:faf-apps", "allow-init-apps-read-app-config-infra:rolebinding", "allow-init-apps-read-app-config-apps:rolebinding"], resource_deps=["clusterroles"], labels=["core"])

if not is_ci:
    k8s_yaml(helm_with_build_cache("tilt/reloader", namespace="faf-ops", values=["config/local.yaml"]))
    k8s_resource(workload="reloader-reloader", new_name="reloader", objects=["reloader-reloader:serviceaccount", "reloader-reloader-metadata-role:role", "reloader-reloader-role:clusterrole", "reloader-reloader-metadata-role-binding:rolebinding", "reloader-reloader-role-binding:clusterrolebinding"], resource_deps=["namespaces"], labels=["core"])

storage_yaml = helm_with_build_cache("cluster/storage", values=["config/local.yaml"], set=["dataPath="+data_absolute_path])
storage_yaml = to_hostpath_storage(storage_yaml)
k8s_yaml(storage_yaml)

volume_identifiers = []
for object in decode_yaml_stream(storage_yaml):
    name = object["metadata"]["name"]
    kind = object["kind"].lower()
    volume_identifiers.append(name + ":" + kind)

k8s_resource(new_name="volumes", objects=volume_identifiers, labels=["core"], trigger_mode=TRIGGER_MODE_MANUAL)

traefik_yaml = helm_with_build_cache("cluster/traefik", values=["config/local.yaml", "cluster/traefik/values-local.yaml"], set=["traefik.ingressRoute.dashboard.matchRule='Host(`traefik.{}`)'".format(base_domain)], namespace="traefik")
k8s_yaml(traefik_yaml)

traefik_identifiers = []
traefik_crds = []
for object in decode_yaml_stream(traefik_yaml):
    name = object["metadata"]["name"]
    kind = object["kind"].lower()
    if kind != "deployment" and kind != "service" and kind != "customresourcedefinition":
        traefik_identifiers.append(name + ":" + kind)
    if kind == "customresourcedefinition":
        traefik_crds.append(name + ":" + kind)

k8s_resource(new_name="traefik-crds", objects=traefik_crds, labels=["traefik"])
agnostic_local_resource("wait-for-traefik-crd", cmd=["kubectl", "wait", "--for=condition=established", "--timeout=60s", "crd/ingressroutes.traefik.io"], resource_deps=["traefik-crds"], labels=["traefik"])
k8s_resource(new_name="traefik-setup", objects=traefik_identifiers, resource_deps=["namespaces", "wait-for-traefik-crd"], labels=["traefik"])
k8s_resource(workload="traefik", port_forwards=["443:8443", "80:8000"], resource_deps=["traefik-setup"], labels=["traefik"], links=[link("http://traefik.{}".format(base_domain), "FAF Traefik")])

_, monitoring_yaml = filter_yaml(helm_with_build_cache("ops/monitoring", namespace="faf-ops", values=["config/local.yaml", "ops/monitoring/values-local.yaml"]), kind="Job")
k8s_yaml(monitoring_yaml)

monitoring_accounts = []
monitoring_vm = []
monitoring_crds = []
monitoring_config = []
for object in decode_yaml_stream(monitoring_yaml):
    name = object["metadata"]["name"]
    kind = object["kind"].lower()
    if kind == "serviceaccount" or kind == "role" or kind == "clusterrole" or kind == "rolebinding" or kind == "clusterrolebinding":
        monitoring_accounts.append(name + ":" + kind)
    elif kind == "vmrule" or kind == "vmservicescrape" or kind == "vmnodescrape" or kind == "vmalertmanager" or kind == "vmalert" or kind == "vmagent" or kind == "vmsingle" or kind == "vmpodscrape":
        monitoring_vm.append(name + ":" + kind)
    elif kind == "customresourcedefinition":
        monitoring_crds.append(name + ":" + kind)
    elif kind == "configmap" or kind == "secret":
        monitoring_config.append(name + ":" + kind)

k8s_resource(new_name="monitoring-crds", objects=monitoring_crds, resource_deps=["namespaces"], labels=["monitoring"])
k8s_resource(new_name="monitoring-setup", objects=monitoring_accounts + monitoring_config, resource_deps=["namespaces", "monitoring-crds"], labels=["monitoring"])
k8s_resource(workload="monitoring-grafana", objects=["grafana:ingressroute"], resource_deps=["monitoring-setup"], labels=["monitoring"], links=[link("http://grafana.{}".format(base_domain), "FAF Grafana")])
k8s_resource(workload="monitoring-kube-state-metrics", resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(workload="monitoring-loki", resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(new_name="monitoring-alloy-logs", objects=["monitoring-alloy-logs:alloy"], resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(workload="monitoring-loki-gateway", resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(workload="monitoring-loki-results-cache", resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(workload="monitoring-alloy-operator", resource_deps=["monitoring-setup", "monitoring-alloy-logs", "monitoring-loki-gateway"], labels=["monitoring"])
k8s_resource(workload="monitoring-victoria-metrics-operator", objects=["monitoring-victoria-metrics-operator-admission:validatingwebhookconfiguration"], resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(new_name="monitoring-k8s-stack", objects=["monitoring-victoria-metrics-k8s-stack-core-dns:service", "monitoring-victoria-metrics-k8s-stack-kube-controller-manager:service", "monitoring-victoria-metrics-k8s-stack-kube-etcd:service", "monitoring-victoria-metrics-k8s-stack-kube-scheduler:service"], resource_deps=["monitoring-setup"], labels=["monitoring"])
k8s_resource(new_name="monitoring-vm", objects=monitoring_vm, resource_deps=["monitoring-victoria-metrics-operator"], labels=["monitoring"])

postgres_yaml = helm_with_build_cache("infra/postgres", namespace="faf-infra", values=["config/local.yaml"])
postgres_init_user_yaml, postgres_resource_yaml = filter_yaml(postgres_yaml, {"app": "postgres-sync-db-user"})
k8s_yaml(postgres_init_user_yaml)
k8s_yaml(postgres_resource_yaml)
k8s_yaml(helm_with_build_cache("apps/faf-postgres", namespace="faf-apps", values=["config/local.yaml"]))
k8s_resource(workload="postgres", objects=["postgres:configmap", "postgres:secret", "postgres:service:faf-apps"], port_forwards=["5432"], resource_deps=["volumes"], labels=["database"])
postgres_setup_resources = []
for object in decode_yaml_stream(postgres_init_user_yaml):
    postgres_setup_resources.append(object["metadata"]["name"])
    k8s_resource(workload=object["metadata"]["name"], resource_deps=["init-apps", "postgres", "wikijs-config", "ory-hydra-config", "faf-message-broker-config"], labels=["database"])

mariadb_yaml = helm_with_build_cache("infra/mariadb", namespace="faf-infra", values=["config/local.yaml"])
mariadb_init_user_yaml, mariadb_resource_yaml = filter_yaml(mariadb_yaml, {"app": "mariadb-sync-db-user"})
k8s_yaml(mariadb_init_user_yaml)
k8s_yaml(mariadb_resource_yaml)
k8s_yaml(helm_with_build_cache("apps/faf-mariadb", namespace="faf-apps", values=["config/local.yaml"]))
k8s_resource(workload="mariadb", objects=["mariadb:configmap", "mariadb:secret", "mariadb:service:faf-apps"], port_forwards=["3306"], resource_deps=["volumes"], labels=["database"])
mariadb_setup_resources = []
for object in decode_yaml_stream(mariadb_init_user_yaml):
    mariadb_setup_resources.append(object["metadata"]["name"])
    k8s_resource(workload=object["metadata"]["name"], resource_deps=["init-apps", "mariadb", "faf-api-config", "faf-user-service-config", "faf-lobby-server-config", "faf-player-service-config", "faf-replay-server-config", "faf-policy-server-config", "faf-league-service-config", "wordpress-config", "ergochat-config", "faf-icebreaker-config"], labels=["database"])

# mongodb_yaml = helm_with_build_cache("infra/mongodb", namespace="faf-infra", values=["config/local.yaml"])
# mongodb_init_user_yaml, mongodb_resource_yaml = filter_yaml(mongodb_yaml, {"app": "mongodb-sync-db-user"})
# k8s_yaml(mongodb_init_user_yaml)
# k8s_yaml(mongodb_resource_yaml)
# k8s_yaml(helm_with_build_cache("apps/faf-mongodb", namespace="faf-apps", values=["config/local.yaml"]))
# k8s_resource(workload="mongodb", objects=["mongodb:configmap", "mongodb:secret", "mongodb:service:faf-apps"], port_forwards=["27017"], resource_deps=["volumes"], labels=["database"])
# mongodb_setup_resources = []
# for object in decode_yaml_stream(mongodb_init_user_yaml):
#     mongodb_setup_resources.append(object["metadata"]["name"])
#     k8s_resource(workload=object["metadata"]["name"], resource_deps=["init-apps", "mongodb", "nodebb-config"], labels=["database"])

rabbitmq_yaml = helm_with_build_cache("apps/rabbitmq", namespace="faf-apps", values=["config/local.yaml"])
rabbitmq_init_user_yaml, rabbitmq_resource_yaml = filter_yaml(rabbitmq_yaml, {"app": "rabbitmq-sync-user"})
k8s_yaml(rabbitmq_init_user_yaml)
k8s_yaml(rabbitmq_resource_yaml)
k8s_resource(workload="rabbitmq", objects=["rabbitmq:configmap", "rabbitmq:secret"], port_forwards=["15672", "5672"], resource_deps=["volumes"], labels=["rabbitmq"])
rabbitmq_setup_resources = []
for object in decode_yaml_stream(rabbitmq_init_user_yaml):
    rabbitmq_setup_resources.append(object["metadata"]["name"])
    k8s_resource(workload=object["metadata"]["name"], resource_deps=["init-apps", "rabbitmq", "faf-api-config", "faf-icebreaker-config", "faf-lobby-server-config", "faf-player-service-config", "faf-message-broker-config", "debezium-config", "faf-league-service-config", "faf-user-service-config"], labels=["rabbitmq"])

k8s_yaml(cronjob_to_job(helm_with_build_cache("apps/faf-db-migrations", namespace="faf-apps", values=["config/local.yaml"])))
k8s_resource(workload="faf-db-migrations", objects=["faf-db-migrations:secret"], resource_deps=mariadb_setup_resources, labels=["database"])

k8s_yaml(helm_with_build_cache("apps/ergochat", namespace="faf-apps", values=["config/local.yaml"]))
k8s_resource(new_name="ergochat-config", objects=["ergochat:configmap", "ergochat:secret"], labels=["chat"])
k8s_resource(workload="ergochat", objects=["ergochat-webirc:ingressroute"], resource_deps=["traefik"] + mariadb_setup_resources, port_forwards=["8097:8097"], labels=["chat"])

k8s_yaml(helm_with_build_cache("apps/wordpress", namespace="faf-apps", values=["config/local.yaml"]))
k8s_resource(new_name="wordpress-config", objects=["wordpress:configmap", "wordpress:secret"], labels=["website"])
k8s_resource(workload="wordpress", objects=["wordpress:ingressroute"], resource_deps=["traefik"], labels=["website"], links=[link("http://direct.{}".format(base_domain), "FAF Wordpress")])

k8s_yaml(helm_with_build_cache("apps/wikijs", namespace="faf-apps", values=["config/local.yaml"]))
k8s_resource(new_name="wikijs-config", objects=["wikijs:configmap", "wikijs:secret", "wikijs-sso:configmap"], labels=["misc"])
k8s_resource(workload="wikijs", objects=["wikijs:ingressroute"], resource_deps=["traefik"] + postgres_setup_resources, labels=["misc"], links=[link("http://wiki.{}".format(base_domain), "FAF Wiki")])

nodebb_config_yaml, _ = filter_yaml(helm_with_build_cache("apps/nodebb", namespace="faf-apps", values=["config/local.yaml"]), kind="ConfigMap|Secret")
k8s_yaml(nodebb_config_yaml)
k8s_resource(new_name="nodebb-config", objects=["nodebb:configmap", "nodebb:secret"], labels=["misc"])

# k8s_yaml(helm_with_build_cache("apps/nodebb", namespace="faf-apps", values=["config/local.yaml"]))
# k8s_resource(new_name="nodebb-config", objects=["nodebb:configmap", "nodebb:secret"], labels=["misc"])
# k8s_resource(workload="nodebb", objects=["nodebb:ingressroute"], resource_deps=["traefik"] + mongodb_setup_resources, labels=["misc"], links=[link("http://forum.{}".format(base_domain), "FAF Forum")])

k8s_yaml(keep_objects_of_kind(helm_with_build_cache("apps/debezium", namespace="faf-apps", values=["config/local.yaml"]), kinds=["ConfigMap", "Secret"]))
k8s_resource(new_name="debezium-config", objects=["debezium:configmap", "debezium:secret"], labels=["database"])

hydra_deps = ["ory-hydra-migration", "traefik"]
hydra_labels = ["hydra"]
hydra_links = [link("http://hydra.{}/.well-known/openid-configuration".format(base_domain), "Hydra Configuration")]
hydra_yaml = helm_with_build_cache("apps/ory-hydra", namespace="faf-apps", values=["config/local.yaml"])
hydra_client_create_yaml, hydra_resources_yaml = filter_yaml(hydra_yaml, {"app": "ory-hydra-create-clients"})
_, hydra_resources_yaml = filter_yaml(hydra_resources_yaml, {"app": "ory-hydra-janitor"})
hydra_patch = {"URLS_SELF_ISSUER": "http://ory-hydra:4444", "URLS_SELF_PUBLIC": "http://hydra.{}".format(base_domain), "URLS_LOGIN": "http://user.{}/oauth2/login".format(base_domain), "URLS_CONSENT": "http://user.{}/oauth2/consent".format(base_domain), "URLS_DEVICE_VERIFICATION": "http://user.{}/oauth2/device-login".format(base_domain), "URLS_DEVICE_SUCCESS": "http://user.{}/oauth2/device-done".format(base_domain), "DEV": "true"}
hydra_resources_yaml = patch_config(hydra_resources_yaml, "ory-hydra", hydra_patch)
k8s_yaml(hydra_resources_yaml)
k8s_yaml(hydra_client_create_yaml)
k8s_resource(new_name="ory-hydra-config", objects=["ory-hydra:configmap", "ory-hydra:secret"], labels=hydra_labels)
k8s_resource(workload="ory-hydra-migration", resource_deps=["ory-hydra-config"] + postgres_setup_resources, labels=hydra_labels)
k8s_resource(workload="ory-hydra", objects=["ory-hydra:ingressroute"], resource_deps=hydra_deps, port_forwards=["4444", "4445"], labels=hydra_labels, links=hydra_links)
for object in decode_yaml_stream(hydra_client_create_yaml):
    k8s_resource(workload=object["metadata"]["name"], resource_deps=["ory-hydra"], labels=["hydra"])

k8s_yaml(keep_objects_of_kind(helm_with_build_cache("apps/faf-voting", namespace="faf-apps", values=["config/local.yaml"]), kinds=["ConfigMap", "Secret"]))
k8s_resource(new_name="faf-voting-config", objects=["faf-voting:configmap", "faf-voting:secret"], labels=["voting"])

k8s_yaml(keep_objects_of_kind(helm_with_build_cache("apps/faf-policy-server", namespace="faf-apps"), kinds=["ConfigMap", "Secret"]))
k8s_resource(new_name="faf-policy-server-config", objects=["faf-policy-server:configmap", "faf-policy-server:secret"], labels=["lobby"])

# k8s_yaml(helm_with_build_cache("apps/faf-content", namespace="faf-apps", values=["config/local.yaml"]))
# k8s_resource(new_name="faf-content-config", objects=["faf-content:configmap"], labels=["content"])
# k8s_resource(workload="faf-content", objects=["faf-content:ingressroute", "cors:middleware", "redirect-replay-subdomain:middleware"], resource_deps=["traefik"], labels=["content"], links=[link("http://content.{}".format(base_domain), "FAForever Content")])

user_service_deps = ["faf-db-migrations", "ory-hydra"]
user_service_labels = ["user"]
user_service_links = [link("http://user.{}/register".format(base_domain), "User Service Registration")]
user_service_patch = {"HYDRA_TOKEN_ISSUER": "http://ory-hydra:4444", "HYDRA_JWKS_URL": "http://ory-hydra:4444/.well-known/jwks.json", "LOBBY_URL":"ws://ws.{}".format(base_domain), "REPLAY_URL":"ws://replay-ws.{}".format(base_domain), "QUARKUS_LOG_CONSOLE_JSON_ENABLED": "false"}
proxy_local_service_if_set(service_name="faf-user-service", service_chart="apps/faf-user-service", service_namespace="faf-apps", service_deps=user_service_deps, additional_values=["apps/faf-user-service/values-prod.yaml"], service_labels=user_service_labels, service_links=user_service_links, config_patch=user_service_patch)

website_deps = ["wordpress"]
website_labels = ["website"]
website_links = [link("http://www.{}".format(base_domain), "FAForever Website")]
website_patch = {"OAUTH_URL": "http://ory-hydra:4444", "OAUTH_PUBLIC_URL": "http://hydra.{}".format(base_domain), "API_URL": "http://faf-api:8010", "WP_URL": "http://wordpress:80"}
proxy_local_service_if_set(service_name="faf-website", service_chart="apps/faf-website", service_namespace="faf-apps", service_deps=website_deps, service_labels=website_labels, service_links=website_links, additional_values=["apps/faf-website/values-prod.yaml"], config_patch=website_patch)

api_deps = ["faf-db-migrations", "ory-hydra"] + rabbitmq_setup_resources
api_labels = ["api"]
api_links = [link("http://api.{}".format(base_domain), "FAF API")]
api_patch = {"JWT_FAF_HYDRA_ISSUER": "http://ory-hydra:4444", "REPLAY_DOWNLOAD_URL_FORMAT": "http://replays.{}/%s".format(base_domain), "MOD_DOWNLOAD_URL_FORMAT": "http://content.{}/mods/%s".format(base_domain), "MAP_DOWNLOAD_URL_FORMAT": "http://content.{}/maps/%s".format(base_domain), "FEATURED_MOD_URL_FORMAT":"http://content.{}/legacy-featured-mod-files/%s/%s".format(base_domain), "AVATAR_DOWNLOAD_URL_FORMAT":"http://content.{}/faf/avatars/%s".format(base_domain)}
proxy_local_service_if_set(service_name="faf-api", service_chart="apps/faf-api", service_namespace="faf-apps", service_deps=api_deps, service_labels=api_labels, service_links=api_links, config_patch=api_patch)

league_service_deps = mariadb_setup_resources + rabbitmq_setup_resources
league_service_labels = ["leagues"]
proxy_local_service_if_set(service_name="faf-league-service", service_chart="apps/faf-league-service", service_namespace="faf-apps", service_deps=league_service_deps, service_labels=league_service_labels)

lobby_server_deps = ["faf-db-migrations"] + rabbitmq_setup_resources
lobby_server_labels = ["lobby"]
lobby_server_patch = {"HYDRA_JWKS_URI": "http://ory-hydra:4444/.well-known/jwks.json"}
proxy_local_service_if_set(service_name="faf-lobby-server", service_chart="apps/faf-lobby-server", service_namespace="faf-apps", service_deps=lobby_server_deps, service_labels=lobby_server_labels, config_patch=lobby_server_patch)

message_broker_deps = ["ory-hydra"] + rabbitmq_setup_resources + postgres_setup_resources
message_broker_labels = ["lobby"]
message_broker_patch = {"HYDRA_TOKEN_ISSUER": "http://ory-hydra:4444", "USE_POLICY_SERVER": "false", "QUARKUS_LOG_CONSOLE_JSON_ENABLED": "false", "QUARKUS_LOG_CATEGORY__COM_FAFOREVER__LEVEL":"DEBUG", "QUARKUS_LOG_CATEGORY__IO_QUARKUS_WEBSOCKETS_NEXT_TRAFFIC__LEVEL":"DEBUG", "QUARKUS_WEBSOCKETS_NEXT_SERVER_TRAFFIC_LOGGING_ENABLED":"true"}
proxy_local_service_if_set(service_name="faf-message-broker", service_chart="apps/faf-message-broker", service_namespace="faf-apps", service_deps=message_broker_deps, service_labels=message_broker_labels, config_patch=message_broker_patch)

player_service_deps = rabbitmq_setup_resources + mariadb_setup_resources
player_service_labels = ["lobby"]
proxy_local_service_if_set(service_name="faf-player-service", service_chart="apps/faf-player-service", service_namespace="faf-apps", service_deps=player_service_deps, service_labels=player_service_labels)

replay_server_deps = ["faf-db-migrations"]
replay_server_labels = ["replay"]
proxy_local_service_if_set(service_name="faf-replay-server", service_chart="apps/faf-replay-server", service_namespace="faf-apps", service_deps=replay_server_deps, service_labels=replay_server_labels)

tournaments_labels = ["misc"]
tournaments_links = [link("http://tournaments.{}".format(base_domain), "FAF Tournaments")]
proxy_local_service_if_set(service_name="faf-tournaments", service_chart="apps/faf-tournaments", service_namespace="faf-apps", service_deps=["volumes"], service_labels=tournaments_labels, service_links=tournaments_links)

daily_labels = ["misc"]
daily_links = [link("http://daily.{}".format(base_domain), "FAF Daily")]
proxy_local_service_if_set(service_name="faf-daily", service_chart="apps/faf-daily", service_namespace="faf-apps", service_deps=["volumes"], service_labels=daily_labels, service_links=daily_links)

icebreaker_deps = ["faf-db-migrations", "ory-hydra"] + rabbitmq_setup_resources
icebreaker_labels = ["api"]
icebreaker_patch = {"HYDRA_URL": "http://ory-hydra:4444", "XIRSYS_ENABLED": "false", "XIRSYS_TURN_ENABLED": "false", "CLOUDFLARE_ENABLED": "false", "QUARKUS_LOG_CONSOLE_JSON_ENABLED": "false"}
proxy_local_service_if_set(service_name="faf-icebreaker", service_chart="apps/faf-icebreaker", service_namespace="faf-apps", service_deps=icebreaker_deps, service_labels=icebreaker_labels, additional_values=["apps/faf-icebreaker/values-prod.yaml"], config_patch=icebreaker_patch)