4lt/docker-compose-cookbooks
1
0
Fork 0
mirror of https://github.com/nickyeoman/docker-compose-cookbooks.git synced 2026-09-04 02:46:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
88f887c5defb15fad015f9fea7023d654f858c76
docker-compose-cookbooks/_build/portainer_template_build.py
T
nick 88f887c5de new portainer build script
2025-11-26 20:23:15 -08:00

341 lines
11 KiB
Python
Raw Blame History

#!/usr/bin/env python3
"""
Portainer templates generator for nickyeoman/docker-compose-cookbooks
Generates templates.json (Portainer-compatible) based on each project's
docker-compose.yml and sample.env/env-sample.
Behavior:
- Uses master branch for raw GitHub stackfile URLs.
- Skips directories starting with "_" and those ending with "_dev" or "_notes".
- Skips projects whose docker-compose.yml contains "${VOL_PATH".
- Extracts README "## Overview" (exact match) for the description; default fallback.
- Parses sample.env or env-sample, strips inline comments, returns defaults.
- Resolves image lines (handles ${VAR:-default} and ${VAR}) using sample.env defaults.
- Parses ports into strings like "8000:80" or "8080:8080/tcp" for Portainer.
- Parses volumes and converts them into named Docker volumes:
- container path used as container
- named volume created as "<stack>-<container-path-sanitized>" and inserted into "bind"
- Produces a Portainer-friendly JSON structure:
{
"version": "3",
"templates": [
{
"type": "docker-compose",
"title": "<project>",
"name": "<project>",
"note": "...",
"categories": ["Auto"],
"platform": "linux",
"logo": "...",
"description": "...",
"image": "...",
"stackfile": "https://raw.githubusercontent.com/..../master/<project>/docker-compose.yml",
"env": [ {name,label,default}, ... ],
"ports": ["80:80", ...],
"volumes": [ {"container":"/path", "bind":"<named-volume>"}, ... ]
}
]
}
"""
from pathlib import Path
import argparse
import json
import re
import requests
import sys
# Constants
SCRIPT_DIR = Path(__file__).resolve().parent
REPO_ROOT = SCRIPT_DIR.parent
OUTPUT_FILE = REPO_ROOT / "templates.json"
GITHUB_RAW_BASE = "https://raw.githubusercontent.com/nickyeoman/docker-compose-cookbooks/master"
ASSETS_BASE = "https://i.4lt.ca/cookbook"
SKIP_PAT = "${VOL_PATH"
# -------------------------
# Helpers
# -------------------------
def read_text_safe(p: Path) -> str:
try:
return p.read_text()
except Exception:
return ""
# -------------------------
# Extract "Overview" section from README.md (exact "## Overview")
# -------------------------
def extract_overview(readme_path: Path, project_name: str) -> str:
text = read_text_safe(readme_path)
if not text:
return f"{project_name} description to come"
lines = text.splitlines()
overview = []
in_section = False
for line in lines:
stripped = line.strip()
if stripped == "## Overview":
in_section = True
continue
if in_section:
if stripped.startswith("#"):
break
if stripped:
overview.append(stripped)
if not overview:
return f"{project_name} description to come"
return " ".join(overview)
# -------------------------
# Logo URL lookup (skip HEAD if nologo True)
# -------------------------
def find_logo_url(dir_path: Path, nologo: bool = False) -> str:
name = dir_path.name
logo_url = f"{ASSETS_BASE}/{name}.png"
default = f"{ASSETS_BASE}/default.png"
if nologo:
return default
try:
resp = requests.head(logo_url, timeout=4)
if resp.status_code == 200:
return logo_url
except Exception:
pass
return default
# -------------------------
# Parse env defaults from sample.env or env-sample (strip comments)
# Returns list of dicts { "name": ..., "default": ... }
# -------------------------
def parse_env_vars(dir_path: Path):
candidates = [dir_path / "sample.env", dir_path / "env-sample"]
env_file = None
for p in candidates:
if p.exists():
env_file = p
break
if not env_file:
return []
env_list = []
for raw in read_text_safe(env_file).splitlines():
line = raw.strip()
if not line or line.startswith("#"):
continue
if "=" in line:
key, val = line.split("=", 1)
key = key.strip()
# strip inline comments after #
val = val.split("#", 1)[0].strip()
# remove surrounding quotes
val = val.strip().strip('"').strip("'")
env_list.append({"name": key, "default": val})
return env_list
# -------------------------
# Resolve the first "image:" line from docker-compose.yml
# Supports ${VAR:-default} and ${VAR}
# -------------------------
VAR_RE = re.compile(r"\$\{([^:}]+)(?:[:-]([^}]+))?\}")
def parse_image(compose_path: Path, env_vars: list) -> str:
text = read_text_safe(compose_path)
if not text:
return ""
env_defaults = {v["name"]: v["default"] for v in env_vars}
for line in text.splitlines():
stripped = line.strip()
if stripped.startswith("image:"):
image = stripped.split("image:", 1)[1].strip().strip('"').strip("'")
# replace ${VAR:-default} or ${VAR} using env_defaults
def repl(m):
var = m.group(1)
default = m.group(2)
return env_defaults.get(var, default or "")
image = VAR_RE.sub(repl, image)
return image
return ""
# -------------------------
# Parse ports into a list of strings Portainer likes
# Examples supported:
# - "8080:80"
# - "9000"
# - "9000:9000/tcp"
# - "53:53/udp"
# -------------------------
def parse_ports(compose_path: Path):
text = read_text_safe(compose_path)
if not text:
return []
ports = []
lines = text.splitlines()
in_ports = False
for line in lines:
stripped = line.strip()
if stripped.startswith("ports:"):
in_ports = True
continue
if in_ports:
if not stripped or not stripped.startswith("-"):
break
# get port string, strip comments/quotes
port_str = stripped[1:].strip().split("#", 1)[0].strip().strip('"').strip("'")
if not port_str:
continue
# normalize space
port_str = port_str.replace(" ", "")
# handle protocol suffix; keep as-is for Portainer
ports.append(port_str)
return ports
# -------------------------
# Parse volumes:
# - Accept mapping forms:
# host:container[:ro|rw]
# container[:ro|rw]
# named-volume:container[:ro|rw]
# - For Portainer templates we'll provide:
# {"container": "/path/in/container", "bind": "<named-volume>"}
# where <named-volume> is generated as "<stack>-<container-path-sanitized>"
# -------------------------
def parse_volumes(compose_path: Path, stack_name: str):
text = read_text_safe(compose_path)
if not text:
return []
vols = []
lines = text.splitlines()
in_volumes = False
for line in lines:
stripped = line.strip()
if stripped.startswith("volumes:"):
in_volumes = True
continue
if in_volumes:
if not stripped or not stripped.startswith("-"):
break
vol_line = stripped[1:].strip().split("#", 1)[0].strip().strip('"').strip("'")
if not vol_line:
continue
# split from right to handle host:container:mode (we want container and ignore host)
parts = vol_line.rsplit(":", 2) # at most 3 parts
# container part is last if there are 2 or more parts, else first
if len(parts) == 1:
container_path = parts[0].strip()
else:
container_path = parts[-2].strip() if len(parts) == 3 else parts[-1].strip()
# explanation:
# - "host:container" -> parts len 2 -> parts[-1] == container
# - "host:container:ro" -> parts len 3 -> parts[-2] == container
# final strip of mode suffix if any left
container_path = re.sub(r":(ro|rw)$", "", container_path)
# ensure container path starts with /
if not container_path.startswith("/"):
# if it's like "config.yaml" or similar, prefix with /
container_path = "/" + container_path.lstrip("/")
# generate a safe named volume
safe = container_path.strip("/").replace("/", "-").replace(".", "-")
if not safe:
safe = "data"
vol_name = f"{stack_name}-{safe}"
vols.append({"container": container_path, "bind": vol_name})
return vols
# -------------------------
# Build a Portainer template object for a project directory
# -------------------------
def generate_template_object(dir_path: Path, nologo: bool = False):
name = dir_path.name
compose_file = dir_path / "docker-compose.yml"
readme_file = dir_path / "README.md"
description = extract_overview(readme_file, name)
logo = find_logo_url(dir_path, nologo=nologo)
env_vars = parse_env_vars(dir_path)
image = parse_image(compose_file, env_vars)
ports = parse_ports(compose_file)
volumes = parse_volumes(compose_file, name)
# env entries: only include those with a name
env_entries = []
for v in env_vars:
if not v.get("name"):
continue
# leave default as empty string if missing (Portainer accepts empty)
env_entries.append({"name": v["name"], "label": v["name"], "default": v.get("default", "")})
# Build stackfile raw URL on master branch
stackfile_url = f"{GITHUB_RAW_BASE}/{name}/docker-compose.yml"
tpl = {
"type": "docker-compose",
"title": name,
"name": name,
"note": "Auto-generated template from repository",
"categories": ["Auto"],
"platform": "linux",
"logo": logo,
"description": description,
# optional convenience field: image
"image": image,
# Portainer expects a full stackfile URL
"stackfile": stackfile_url,
"env": env_entries,
}
# ports: Portainer accepts list of strings like "8000:80" or "53:53/udp"
if ports:
tpl["ports"] = ports
# volumes: produce list of objects with container and bind (named volume)
if volumes:
tpl["volumes"] = volumes
return tpl
# -------------------------
# Main
# -------------------------
def main():
parser = argparse.ArgumentParser(description="Generate Portainer templates.json from compose cookbooks")
parser.add_argument("--nologo", action="store_true", help="skip HEAD requests for logos (faster, dev)")
args = parser.parse_args()
templates = []
for item in REPO_ROOT.iterdir():
if not item.is_dir():
continue
if item.name.startswith("_"):
continue
if item.name.endswith(("_dev", "_notes")):
continue
compose_path = item / "docker-compose.yml"
if not compose_path.exists():
continue
# skip projects still using VOL_PATH (developer needs to fix)
if SKIP_PAT in read_text_safe(compose_path):
print(f"Skipping {item.name}: still uses ${{VOL_PATH}}")
continue
tpl = generate_template_object(item, nologo=args.nologo)
templates.append(tpl)
output = {"version": "3", "templates": templates}
# Write atomically if possible
tmp = OUTPUT_FILE.with_suffix(".tmp")
tmp.write_text(json.dumps(output, indent=2))
tmp.replace(OUTPUT_FILE)
print(f"Generated {OUTPUT_FILE} with {len(templates)} templates.")
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink