docker-compose-artifact-gen

#!/usr/bin/env python3
from pathlib import Path
import subprocess
import argparse
import tempfile
import json
import sys

# Argument setup
parser = argparse.ArgumentParser(description="Create docker compose mender artifact.")
parser.add_argument("--device-types", nargs="*", required=True, help="Target device type identifications")
parser.add_argument("--software-name", required=True, help="Name of software being packaged")
parser.add_argument("--software-version", required=True, help="Value for the software version")

# Path args
parser.add_argument(
    "--output-path", type=Path, default=None,
    help="Path to output file, default to '{software name}-{software version}-artifact.mender'"
)
parser.add_argument(
    "--signing-key", type=Path, default=None,
    help="Path to the private key that will be used to sign the artifact"
)
parser.add_argument(
    "--env", action="append", default=[],
    help="Set compose file environment variable",
)
parser.add_argument(
    "COMPOSEFILE", type=Path, help="Path to docker-compose file"
)
parsed_args, passthrough_args = parser.parse_known_args()

# Convert --env into a .env file
with tempfile.NamedTemporaryFile(mode="w", delete=False) as envfile:
    envfile.write("\n".join(parsed_args.env))
envfile = Path(envfile.name)
envfile = envfile.rename(envfile.with_name("envfile"))

# Build metadata file
metadata = {
    "compose_file": parsed_args.COMPOSEFILE.name,
    "project_name": parsed_args.software_name,
    "envfile": envfile.name,
}
with tempfile.NamedTemporaryFile(mode="w", delete=False) as metafile:
    json.dump(metadata, metafile.file)

# Build output-path & artifact-name
artifact_name = f"{parsed_args.software_name}-{parsed_args.software_version}".replace(" ", "-")
output_path = parsed_args.output_path if parsed_args.output_path else Path(f"{artifact_name}-artifact.mender")
output_path = str(output_path.resolve())

# Populate write command
write_command = [
    "mender-artifact", "write", "module-image",
    "--type", "docker-compose",
    "--artifact-name", artifact_name,
    "--file", str(parsed_args.COMPOSEFILE.resolve()),
    "--file", str(envfile.resolve()),
    "--output-path", output_path,
    "--software-name", parsed_args.software_name,
    "--software-version", parsed_args.software_version,
    "--meta-data", metafile.name,
    "--compression", "gzip",
    *passthrough_args,
]

# Add signing key
if parsed_args.signing_key:
    write_command.extend(["--key", parsed_args.signing_key.resolve()])

# Add each device type that is supported
for device_type in parsed_args.device_types:
    write_command.extend(["--device-type", device_type])

# Create mender artifact
try:
    subprocess.run(write_command, check=True)
except subprocess.CalledProcessError as err:
    print(f"Failed to create Artifact {output_path}:")
    exit_code = err.returncode
else:
    print(f"Artifact {output_path} generated successfully:")
    subprocess.run(["mender-artifact", "read", output_path])
    exit_code = 0
finally:
    Path(metafile.name).unlink(missing_ok=True)

# Always a good idea to return exit code
sys.exit(exit_code)