Merge branch 'main' of https://github.com/drycc/stacks

Author: zhangeamon

Dockerfile

@@ -69,7 +69,7 @@ ENV PATH "/usr/local/python/bin:${PATH}"
 
 ADD requirements.txt /tmp/requirements.txt
 
-RUN UPX_VERSION=4.1.0; \
+RUN UPX_VERSION=5.0.2; \
   OS_ARCH=$(dpkg --print-architecture); \
   wget https://github.com/upx/upx/releases/download/v${UPX_VERSION}/upx-${UPX_VERSION}-${OS_ARCH}_linux.tar.xz; \
   tar -Jxvf upx-${UPX_VERSION}-${OS_ARCH}_linux.tar.xz; \

scripts/checker.py

@@ -60,7 +60,7 @@
         "name": "jmx_exporter",
         "type": "github",
         "owner": "prometheus",
-        "match": "^parent-[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
+        "match": "^[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
     },
     "caddy": {
         "name": "caddy",
@@ -158,18 +158,6 @@
         "owner": "kubernetes",
         "match": "^kubernetes-[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
     },
-    "mc": {
-        "name": "mc",
-        "type": "github",
-        "owner": "minio",
-        "match": "^RELEASE\.[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}-[0-9]{2}-[0-9]{2}Z$",
-    },
-    "minio": {
-        "name": "minio",
-        "type": "github",
-        "owner": "minio",
-        "match": "^RELEASE\.[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}-[0-9]{2}-[0-9]{2}Z$",
-    },
     "nginx": {
         "name": "nginx",
         "type": "github",
@@ -224,6 +212,12 @@
         "owner": "rabbitmq",
         "match": "^v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
     },
+    "rclone": {
+        "name": "rclone",
+        "type": "github",
+        "owner": "rclone",
+        "match": "^v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
+    },
     "redis": {
         "name": "redis",
         "type": "github",
@@ -374,8 +368,14 @@
         "owner": "opensearch-project",
         "match": "^[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
     },
+    "rustfs": {
+        "name": "rustfs",
+        "type": "github",
+        "owner": "rustfs",
+        "match": "^[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
+    },
     "opentelemetry-collector": {
-        "name": "opentelemetry-collector",
+        "name": "opentelemetry-collector-releases",
         "type": "github",
         "owner": "open-telemetry",
         "match": "^v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
@@ -458,6 +458,18 @@
         "owner": "drycc-addons",
         "match": "v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
     },
+    "headscale": {
+        "name": "headscale",
+        "type": "github",
+        "owner": "juanfont",
+        "match": "v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
+    },
+    "tailscale": {
+        "name": "tailscale",
+        "type": "github",
+        "owner": "tailscale",
+        "match": "v[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$",
+    },
 }
 
 

scripts/cleaner.py

@@ -1,21 +1,26 @@
 #!/usr/bin/env python3
 """
-Git Repository Cleaner
+Git Repository Cleaner and OSS Stack Cleaner
 
-This script provides various cleanup operations for git repositories and GitHub issues.
+This script provides various cleanup operations for git repositories, GitHub issues,
+and OSS stack files.
 
 Usage:
     python cleaner.py tags -n 3 [--dry-run] [--confirm]
     python cleaner.py issues --max-issues 100 [--dry-run]
+    python cleaner.py oss-stacks -n 3 [--dry-run]
 """
 
 import argparse
 import subprocess
 import sys
 import os
 import requests
+import oss2
+import re
 from collections import defaultdict
 from typing import List, Dict, Tuple
+from packaging import version
 
 
 def run_command(command: List[str], dry_run: bool = False) -> str:
@@ -286,6 +291,164 @@ def _close_issue(issue_number: int, issue_title: str, headers: Dict[str, str]) -
         print(f"Error closing issue #{issue_number}: {e}")
 
 
+def parse_oss_filename(filename: str) -> Tuple[str, str, str]:
+    s0, s1 = filename.split("/")[-1].split("-linux-")
+    def parse_version(full_name):
+        parts = full_name.split('-')
+        for i in range(len(parts)):
+            potential_version = '-'.join(parts[i:])
+            try:
+                version.parse(potential_version)
+                software_name = '-'.join(parts[:i]) if i > 0 else None
+                return software_name, potential_version
+            except version.InvalidVersion:
+                continue
+        raise ValueError(f"Could not parse version from {full_name}")
+    os_name = s1.rstrip('.tar.gz')
+    stack_name, stack_version = parse_version(s0)
+    return stack_name, stack_version, os_name
+
+
+def clean_oss_stacks(args):
+    """Clean up old OSS stack files, keeping only the latest n versions per stack per OS."""
+    # Initialize OSS bucket
+    try:
+        bucket = oss2.Bucket(
+            oss2.Auth(
+                os.environ.get("OSS_ACCESS_KEY_ID"),
+                os.environ.get("OSS_ACCESS_KEY_SECRET"),
+            ),
+            os.environ.get("OSS_ENDPOINT", "http://oss-accelerate.aliyuncs.com"),
+            'drycc'
+        )
+    except Exception as e:
+        print(f"Error initializing OSS bucket: {e}")
+        sys.exit(1)
+
+    # List all objects in the stacks directory
+    print("Listing OSS objects...")
+    object_keys = []
+    try:
+        for obj in oss2.ObjectIterator(bucket, prefix='stacks/'):
+            if obj.key.endswith('.tar.gz'):
+                object_keys.append(obj.key)
+    except Exception as e:
+        print(f"Error listing OSS objects: {e}")
+        sys.exit(1)
+
+    if not object_keys:
+        print("No stack files found in OSS")
+        return
+
+    print(f"Found {len(object_keys)} stack files")
+
+    # Handle suffix-based deletion
+    if hasattr(args, 'subfix') and args.subfix is not None:
+        print(f"OSS Stack Cleaner - Deleting files with suffix: {args.subfix}")
+        
+        # Find files matching the suffix
+        files_to_delete = []
+        for obj_key in object_keys:
+            # Check if the filename ends with the specified suffix
+            filename = obj_key.split('/')[-1]  # Get just the filename part
+            if filename.endswith(args.subfix):
+                files_to_delete.append(obj_key)
+        
+        if not files_to_delete:
+            print(f"No files found matching suffix: {args.subfix}")
+            return
+
+        print(f"\nFound {len(files_to_delete)} files to delete:")
+        for obj_key in sorted(files_to_delete):
+            print(f"  - {obj_key}")
+
+        # Confirm deletion
+        if not args.dry_run:
+            response = input(f"\nDelete these {len(files_to_delete)} files? (y/N): ")
+            if response.lower() != 'y':
+                print("Aborted by user")
+                return
+
+        # Delete files
+        success_count = 0
+        for obj_key in files_to_delete:
+            try:
+                if args.dry_run:
+                    print(f"[DRY RUN] Would delete: {obj_key}")
+                else:
+                    bucket.delete_object(obj_key)
+                    print(f"Deleted: {obj_key}")
+                success_count += 1
+            except Exception as e:
+                print(f"Error deleting {obj_key}: {e}", file=sys.stderr)
+
+        print(f"\nCompleted: {success_count}/{len(files_to_delete)} files processed")
+        return
+
+    # Handle keep-count based deletion (existing logic)
+    if hasattr(args, 'keep_count') and args.keep_count is not None:
+        if args.keep_count < 1:
+            print("Error: keep-count must be at least 1", file=sys.stderr)
+            sys.exit(1)
+        print(f"OSS Stack Cleaner - Keeping {args.keep_count} latest versions per stack per OS")
+        
+        # Parse and group files by stack and OS
+        stack_os_files = defaultdict(list)
+        
+        for obj_key in object_keys:
+            try:
+                stack_name, stack_version, os_name = parse_oss_filename(obj_key)
+                package_version = version.parse(stack_version)
+                main_version = f"{package_version.major}.{package_version.micro}"
+                stack_os_files[(stack_name, os_name, main_version)].append((obj_key, stack_version))
+            except ValueError as e:
+                print(f"Warning: Skipping invalid filename {obj_key}: {e}")
+                continue
+
+        # Sort versions for each stack-OS combination (newest first)
+        for key in stack_os_files:
+            stack_os_files[key].sort(key=lambda x: version.parse(x[1]), reverse=True)
+
+        # Determine which files to delete
+        files_to_delete = []
+        
+        for (stack_name, os_name, _), files in stack_os_files.items():
+            if len(files) > args.keep_count:
+                # Keep the first n files (newest), delete the rest
+                files_to_delete.extend([file_info[0] for file_info in files[args.keep_count:]])
+                print(f"Stack '{stack_name}' OS '{os_name}': keeping {args.keep_count} versions, deleting {len(files) - args.keep_count}")
+
+        if not files_to_delete:
+            print("No files to delete - all stacks have <= {} versions per OS".format(args.keep_count))
+            return
+
+        print(f"\nFound {len(files_to_delete)} files to delete:")
+        for obj_key in sorted(files_to_delete):
+            print(f"  - {obj_key}")
+
+        # Confirm deletion
+        if not args.dry_run:
+            response = input(f"\nDelete these {len(files_to_delete)} files? (y/N): ")
+            if response.lower() != 'y':
+                print("Aborted by user")
+                return
+
+        # Delete files
+        success_count = 0
+        for obj_key in files_to_delete:
+            try:
+                if args.dry_run:
+                    print(f"[DRY RUN] Would delete: {obj_key}")
+                else:
+                    bucket.delete_object(obj_key)
+                    print(f"Deleted: {obj_key}")
+                success_count += 1
+            except Exception as e:
+                print(f"Error deleting {obj_key}: {e}", file=sys.stderr)
+
+        print(f"\nCompleted: {success_count}/{len(files_to_delete)} files processed")
+
+
 def main():
     parser = argparse.ArgumentParser(
         description='Git repository cleaner with various cleanup operations',
@@ -297,6 +460,10 @@ def main():
   python cleaner.py tags -n 2 --confirm    # Skip confirmation prompt
   python cleaner.py issues --max-issues 50 # Keep 50 most recent issues
   python cleaner.py issues --dry-run       # Preview issue cleanup
+  python cleaner.py oss-stacks -n 3        # Keep 3 latest versions per stack per OS
+  python cleaner.py oss-stacks -n 2 --dry-run # Preview OSS stack cleanup
+  python cleaner.py oss-stacks -s linux-arm64-debian-12.tar.gz # Delete files with specific suffix
+  python cleaner.py oss-stacks -s linux-amd64-debian-12.tar.gz --dry-run # Preview suffix-based deletion
 
 Note: Issues cleanup requires admin permissions to delete issues.
 If deletion fails, issues will be closed instead.
@@ -321,6 +488,18 @@ def main():
     issues_parser.add_argument('--dry-run', action='store_true',
                              help='Only print commands without executing them')
 
+    # OSS stacks cleanup parser
+    oss_parser = subparsers.add_parser('oss-stacks', help='Clean up old OSS stack files')
+    oss_parser.add_argument('--dry-run', action='store_true',
+                           help='Only print commands without executing them')
+    
+    # Make -n and -s mutually exclusive
+    oss_group = oss_parser.add_mutually_exclusive_group(required=True)
+    oss_group.add_argument('-n', '--keep-count', type=int,
+                          help='Number of latest versions to keep for each stack per OS')
+    oss_group.add_argument('-s', '--subfix', type=str,
+                          help='Suffix pattern to match files for deletion (e.g., linux-arm64-debian-12.tar.gz)')
+
     args = parser.parse_args()
 
     if not args.action:
@@ -331,6 +510,8 @@ def main():
         clean_tags(args)
     elif args.action == 'issues':
         clean_github_issues(args)
+    elif args.action == 'oss-stacks':
+        clean_oss_stacks(args)
     else:
         parser.error(f"Unknown action: {args.action}")
 

scripts/storage.py

@@ -49,17 +49,34 @@ def upload_list(stack_name, dist_dir):
 
 
 def symlink(stack_name, version):
+
+    def get_system_version(obj_key):
+        _, system, system_version = obj_key.strip(".tar.gz").rsplit("-", 2)
+        return f"{system}-{system_version}"
+
     object_list = [
         obj.key for obj in bucket.list_objects(
             f"stacks/{stack_name}/{stack_name}-{version}.").object_list
     ]
     prefix = f"stacks/{stack_name}/{stack_name}-"
-    version_list = sorted(
-        [obj.replace(prefix, "").split("-", 1)[0] for obj in object_list],
-        key=parse,
-        reverse=True,
-    )
+    # Build a map of system-version to object keys
+    version_map = {}
+    for obj in object_list:
+        system = get_system_version(obj)
+        if system not in version_map:
+            version_map[system] = [obj]
+        else:
+            version_map[system].append(obj)
+    for key, value in version_map.items():
+        version_list = sorted(
+            [obj.replace(prefix, "").split("-", 1)[0] for obj in value],
+            key=parse,
+            reverse=True,
+        )
+        version_map[key] = version_list
+
     for obj in object_list:
+        version_list = version_map[get_system_version(obj)]
         if obj.startswith(f"{prefix}{version_list[0]}-"):
             symlink = re.sub(r"%s.([0-9]\.?){1,}" % f"{prefix}{version}", f"{prefix}{version}", obj)
             bucket.put_symlink(obj, symlink)

stacks/mc/build.sh stacks/headscale/build.shstacks/mc/build.sh renamed to stacks/headscale/build.sh

@@ -8,9 +8,10 @@ function build() {
   generate-stack-path
   BIN_DIR="${DATA_DIR}"/bin
   mkdir -p "${BIN_DIR}"
-  version=$(echo ${STACK_VERSION} | awk -F "." '{print "RELEASE."$1"-"$2"-"$3"T"$4"-"$5"-"$6"Z"}')
-  curl -fsSL -o "${BIN_DIR}"/"${STACK_NAME}" https://dl.min.io/client/mc/release/linux-${OS_ARCH}/archive/mc.${version}
+  curl -fsSL "https://github.com/juanfont/headscale/releases/download/v${STACK_VERSION}/headscale_${STACK_VERSION}_linux_${OS_ARCH}" -o "${BIN_DIR}/${STACK_NAME}"
   chmod +x "${BIN_DIR}"/"${STACK_NAME}"
+  # upx
+  upx --lzma --best "${BIN_DIR}"/*
 }
 
 # call build stack

stacks/jmx_exporter/build.sh

@@ -8,12 +8,13 @@ function build() {
   generate-stack-path
   BIN_DIR="${DATA_DIR}"/bin
   mkdir -p "${BIN_DIR}"
-  curl -fsSL -o tmp.tar.gz https://github.com/prometheus/jmx_exporter/archive/refs/tags/parent-${STACK_VERSION}.tar.gz
+  curl -fsSL -o tmp.tar.gz https://github.com/prometheus/jmx_exporter/archive/refs/tags/${STACK_VERSION}.tar.gz
   tar -xzf tmp.tar.gz
-  mv jmx_exporter-parent-${STACK_VERSION}/example_configs/ "${DATA_DIR}"
-  rm -rf jmx_exporter-parent-${STACK_VERSION} jmx_exporter-${STACK_VERSION}.linux-${OS_ARCH} tmp.tar.gz
-  curl -fsSL -o "${DATA_DIR}"/jmx_prometheus_httpserver.jar https://repo1.maven.org/maven2/io/prometheus/jmx/jmx_prometheus_httpserver/${STACK_VERSION}/jmx_prometheus_httpserver-${STACK_VERSION}.jar
-  curl -fsSL -o "${DATA_DIR}"/jmx_prometheus_javaagent.jar https://repo1.maven.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/${STACK_VERSION}/jmx_prometheus_javaagent-${STACK_VERSION}.jar 
+  mv jmx_exporter-${STACK_VERSION}/examples/ "${DATA_DIR}"
+  rm -rf jmx_exporter-${STACK_VERSION} jmx_exporter-${STACK_VERSION}.linux-${OS_ARCH} tmp.tar.gz
+  curl -fsSL -o "${DATA_DIR}"/jmx_prometheus_standalone.jar https://github.com/prometheus/jmx_exporter/releases/download/${STACK_VERSION}/jmx_prometheus_standalone-${STACK_VERSION}.jar
+  curl -fsSL -o "${DATA_DIR}"/jmx_prometheus_javaagent.jar https://github.com/prometheus/jmx_exporter/releases/download/${STACK_VERSION}/jmx_prometheus_javaagent-${STACK_VERSION}.jar
+  curl -fsSL -o "${DATA_DIR}"/jmx_prometheus_isolator_javaagent.jar https://github.com/prometheus/jmx_exporter/releases/download/${STACK_VERSION}/jmx_prometheus_isolator_javaagent-${STACK_VERSION}.jar
 }
 
 # call build stack