1#!/usr/bin/env python3
2"""Upgrade or add azure-sdk-bom in a Maven or Gradle project using OpenRewrite.
3 
4Detects the build system automatically and applies the appropriate OpenRewrite
5recipes.  All operations use OpenRewrite — no manual XML/text manipulation.
6 
7Step 1 – Add or upgrade BOM:
8- Maven (add):     org.openrewrite.maven.AddManagedDependency
9- Maven (upgrade): org.openrewrite.maven.UpgradeDependencyVersion
10- Gradle (add):    org.openrewrite.gradle.AddPlatformDependency
11- Gradle (upgrade):org.openrewrite.gradle.UpgradeDependencyVersion
12 
13Step 2 – Remove redundant explicit versions:
14- Maven:  org.openrewrite.maven.RemoveRedundantDependencyVersions
15- Gradle: org.openrewrite.gradle.RemoveRedundantDependencyVersions
16 
17Usage:
18    python3 upgrade_bom.py <project_dir> <bom_version> [options]
19    python3 upgrade_bom.py --get-latest-version
20 
21Arguments:
22    project_dir   Path to the project root (must contain pom.xml or build.gradle).
23    bom_version   Target azure-sdk-bom version to apply. Resolve the latest stable version first.
24 
25Options:
26    --mvn <cmd>     Maven command override.
27    --gradle <cmd>  Gradle command override.
28"""
29 
30from __future__ import annotations
31 
32import argparse
33import os
34import re
35import stat
36import subprocess
37import sys
38import textwrap
39import urllib.error
40import urllib.request
41import xml.etree.ElementTree as ET
42 
43GROUP_ID = "com.azure"
44ARTIFACT_ID = "azure-sdk-bom"
45BOM_POM_URL = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/boms/azure-sdk-bom/pom.xml"
46POM_NAMESPACE = {"m": "http://maven.apache.org/POM/4.0.0"}
47 
48# Maven constants
49MVN_REWRITE_PLUGIN = "org.openrewrite.maven:rewrite-maven-plugin"
50MVN_REWRITE_ARTIFACT_COORDS = "org.openrewrite:rewrite-maven"
51MVN_UPGRADE_RECIPE = "org.openrewrite.maven.UpgradeDependencyVersion"
52MVN_ADD_MANAGED_RECIPE = "org.openrewrite.maven.AddManagedDependency"
53MVN_REMOVE_REDUNDANT_RECIPE = "org.openrewrite.maven.RemoveRedundantDependencyVersions"
54 
55# Gradle constants
56GRADLE_UPGRADE_RECIPE = "org.openrewrite.gradle.UpgradeDependencyVersion"
57GRADLE_ADD_PLATFORM_RECIPE = "org.openrewrite.gradle.AddPlatformDependency"
58GRADLE_REMOVE_REDUNDANT_RECIPE = "org.openrewrite.gradle.RemoveRedundantDependencyVersions"
59REWRITE_YML_NAME = "rewrite.yml"
60GRADLE_PLUGIN_MARKER = "// --- openrewrite-upgrade-bom-plugin (auto-added, safe to remove) ---"
61 
62# ---------------------------------------------------------------------------
63# Build-system detection
64# ---------------------------------------------------------------------------
65 
66def _detect_build_system(project_dir: str) -> str:
67    """Return 'maven' or 'gradle' depending on which build file is present."""
68    if os.path.isfile(os.path.join(project_dir, "pom.xml")):
69        return "maven"
70    for name in ("build.gradle", "build.gradle.kts"):
71        if os.path.isfile(os.path.join(project_dir, name)):
72            return "gradle"
73    return "unknown"
74 
75 
76def _get_latest_bom_version() -> str:
77    try:
78        with urllib.request.urlopen(BOM_POM_URL) as response:
79            pom_xml = response.read()
80    except urllib.error.URLError as exc:
81        raise SystemExit(f"Failed to download {BOM_POM_URL}: {exc}") from exc
82 
83    try:
84        root = ET.fromstring(pom_xml)
85    except ET.ParseError as exc:
86        raise SystemExit(f"Failed to parse BOM pom.xml: {exc}") from exc
87 
88    version = root.findtext("m:version", namespaces=POM_NAMESPACE)
89    if not version:
90        raise SystemExit("Failed to find the azure-sdk-bom <version> in pom.xml")
91 
92    return version.strip()
93 
94 
95# ---------------------------------------------------------------------------
96# Maven helpers
97# ---------------------------------------------------------------------------
98 
99def _detect_maven(project_dir: str) -> str:
100    if sys.platform == "win32":
101        wrapper = os.path.join(project_dir, "mvnw.cmd")
102        # .cmd files on Windows are invoked by the shell; no executable bit needed.
103        if os.path.isfile(wrapper):
104            return wrapper
105    else:
106        wrapper = os.path.join(project_dir, "mvnw")
107        if os.path.isfile(wrapper):
108            if not os.access(wrapper, os.X_OK):
109                # Wrapper exists but isn't executable (common after fresh clones
110                # on filesystems that don't preserve the +x bit). Try to fix it.
111                try:
112                    mode = os.stat(wrapper).st_mode
113                    os.chmod(wrapper, mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
114                    print(f"[upgrade_bom] Added executable bit to {wrapper}.")
115                except OSError as exc:
116                    print(
117                        f"[upgrade_bom] WARNING: mvnw exists at {wrapper} but is not "
118                        f"executable and chmod failed ({exc}); falling back to 'mvn'.",
119                        file=sys.stderr,
120                    )
121                    return "mvn"
122            if os.access(wrapper, os.X_OK):
123                return wrapper
124    return "mvn"
125 
126 
127def _has_maven_bom_entry(pom_path: str) -> bool:
128    try:
129        tree = ET.parse(pom_path)
130    except ET.ParseError:
131        return False
132    ns = {"m": "http://maven.apache.org/POM/4.0.0"}
133    for dep in tree.findall(".//m:dependencyManagement/m:dependencies/m:dependency", ns):
134        gid = dep.find("m:groupId", ns)
135        aid = dep.find("m:artifactId", ns)
136        if gid is not None and aid is not None:
137            if gid.text == GROUP_ID and aid.text == ARTIFACT_ID:
138                return True
139    for dep in tree.findall(".//dependencyManagement/dependencies/dependency"):
140        gid = dep.find("groupId")
141        aid = dep.find("artifactId")
142        if gid is not None and aid is not None:
143            if gid.text == GROUP_ID and aid.text == ARTIFACT_ID:
144                return True
145    return False
146 
147 
148def _run_maven_recipe(mvn_cmd: str, project_dir: str, recipe: str, options: str) -> int:
149    """Run an OpenRewrite recipe via the rewrite-maven-plugin."""
150    cmd = [
151        mvn_cmd, "-U",
152        f"{MVN_REWRITE_PLUGIN}:run",
153        f"-Drewrite.recipeArtifactCoordinates={MVN_REWRITE_ARTIFACT_COORDS}",
154        f"-Drewrite.activeRecipes={recipe}",
155        f"-Drewrite.options={options}",
156    ]
157    print(f"[upgrade_bom] Running: {' '.join(cmd)}")
158    return subprocess.run(cmd, cwd=project_dir).returncode
159 
160 
161def _handle_maven(project_dir: str, bom_version: str, mvn_cmd: str | None) -> int:
162    pom_path = os.path.join(project_dir, "pom.xml")
163    mvn = mvn_cmd or _detect_maven(project_dir)
164 
165    # Step 1: Add or upgrade the BOM
166    if not _has_maven_bom_entry(pom_path):
167        print("[upgrade_bom] No existing azure-sdk-bom entry found — adding via AddManagedDependency.")
168        options = ",".join([
169            f"groupId={GROUP_ID}",
170            f"artifactId={ARTIFACT_ID}",
171            f"version={bom_version}",
172            "type=pom",
173            "scope=import",
174        ])
175        rc = _run_maven_recipe(mvn, project_dir, MVN_ADD_MANAGED_RECIPE, options)
176        if rc != 0:
177            print(f"[upgrade_bom] ERROR: AddManagedDependency exited with code {rc}", file=sys.stderr)
178            return rc
179        print(f"[upgrade_bom] azure-sdk-bom {bom_version} added successfully.")
180    else:
181        print(f"[upgrade_bom] Existing azure-sdk-bom entry found — upgrading to {bom_version}.")
182        options = ",".join([
183            f"groupId={GROUP_ID}",
184            f"artifactId={ARTIFACT_ID}",
185            f"newVersion={bom_version}",
186            "overrideManagedVersion=true",
187        ])
188        rc = _run_maven_recipe(mvn, project_dir, MVN_UPGRADE_RECIPE, options)
189        if rc != 0:
190            print(f"[upgrade_bom] ERROR: UpgradeDependencyVersion exited with code {rc}", file=sys.stderr)
191            return rc
192        print(f"[upgrade_bom] azure-sdk-bom upgraded to {bom_version} successfully.")
193 
194    # Step 2: Remove explicit versions from Azure deps managed by the BOM
195    print("[upgrade_bom] Removing redundant explicit versions for Azure dependencies...")
196    options = f"groupPattern={GROUP_ID}*,onlyIfManagedVersionIs=GTE"
197    rc = _run_maven_recipe(mvn, project_dir, MVN_REMOVE_REDUNDANT_RECIPE, options)
198    if rc != 0:
199        print(f"[upgrade_bom] WARNING: RemoveRedundantDependencyVersions exited with code {rc}", file=sys.stderr)
200    else:
201        print("[upgrade_bom] Redundant explicit versions removed successfully.")
202    return rc
203 
204 
205# ---------------------------------------------------------------------------
206# Gradle helpers
207# ---------------------------------------------------------------------------
208 
209def _detect_gradle(project_dir: str) -> str:
210    if sys.platform == "win32":
211        wrapper = os.path.join(project_dir, "gradlew.bat")
212        if os.path.isfile(wrapper):
213            return wrapper
214    else:
215        wrapper = os.path.join(project_dir, "gradlew")
216        if os.path.isfile(wrapper):
217            if not os.access(wrapper, os.X_OK):
218                try:
219                    mode = os.stat(wrapper).st_mode
220                    os.chmod(wrapper, mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
221                    print(f"[upgrade_bom] Added executable bit to {wrapper}.")
222                except OSError as exc:
223                    print(
224                        f"[upgrade_bom] WARNING: gradlew exists at {wrapper} but is not "
225                        f"executable and chmod failed ({exc}); falling back to 'gradle'.",
226                        file=sys.stderr,
227                    )
228                    return "gradle"
229            if os.access(wrapper, os.X_OK):
230                return wrapper
231    return "gradle"
232 
233 
234def _find_gradle_build_file(project_dir: str) -> str | None:
235    for name in ("build.gradle", "build.gradle.kts"):
236        path = os.path.join(project_dir, name)
237        if os.path.isfile(path):
238            return path
239    return None
240 
241 
242def _is_kotlin_dsl(build_file: str) -> bool:
243    return build_file.endswith(".kts")
244 
245 
246def _has_gradle_bom_entry(build_file: str) -> bool:
247    """Check whether build.gradle already references azure-sdk-bom."""
248    try:
249        with open(build_file, "r", encoding="utf-8") as f:
250            content = f.read()
251    except OSError:
252        return False
253    return f"{GROUP_ID}:{ARTIFACT_ID}" in content
254 
255 
256def _create_rewrite_yml(project_dir: str, bom_version: str, has_bom: bool) -> str:
257    """Create a temporary rewrite.yml with the appropriate OpenRewrite recipes.
258 
259    When has_bom is True, uses UpgradeDependencyVersion to upgrade the existing BOM.
260    When has_bom is False, uses AddPlatformDependency to add a new enforcedPlatform BOM.
261    Always includes RemoveRedundantDependencyVersions as a final step.
262    """
263    yml_path = os.path.join(project_dir, REWRITE_YML_NAME)
264    recipes: list[str] = []
265 
266    if has_bom:
267        recipes.append(textwrap.dedent(f"""\
268          - org.openrewrite.gradle.UpgradeDependencyVersion:
269              groupId: {GROUP_ID}
270              artifactId: {ARTIFACT_ID}
271              newVersion: {bom_version}"""))
272    else:
273        recipes.append(textwrap.dedent(f"""\
274          - org.openrewrite.gradle.AddPlatformDependency:
275              groupId: {GROUP_ID}
276              artifactId: {ARTIFACT_ID}
277              version: {bom_version}
278              configuration: implementation
279              enforced: true"""))
280 
281    recipes.append(textwrap.dedent(f"""\
282          - org.openrewrite.gradle.RemoveRedundantDependencyVersions:
283              groupPattern: {GROUP_ID}*
284              onlyIfManagedVersionIs: GTE"""))
285 
286    yml_content = textwrap.dedent("""\
287        ---
288        type: specs.openrewrite.org/v1beta/recipe
289        name: com.azure.UpgradeBom
290        displayName: Upgrade azure-sdk-bom and remove redundant versions
291        recipeList:
292    """) + "\n".join(recipes) + "\n"
293 
294    with open(yml_path, "w", encoding="utf-8") as f:
295        f.write(yml_content)
296    print(f"[upgrade_bom] Created {yml_path}")
297    return yml_path
298 
299 
300def _inject_gradle_rewrite_plugin(build_file: str) -> bool:
301    """Temporarily add the OpenRewrite plugin to build.gradle if not present.
302 
303    Returns True if the plugin block was injected (and should be cleaned up).
304    """
305    with open(build_file, "r", encoding="utf-8") as f:
306        content = f.read()
307 
308    if "org.openrewrite.rewrite" in content:
309        return False
310 
311    kotlin = _is_kotlin_dsl(build_file)
312    if kotlin:
313        plugin_line = '    id("org.openrewrite.rewrite") version "latest.release"'
314    else:
315        plugin_line = '    id "org.openrewrite.rewrite" version "latest.release"'
316 
317    rewrite_block_kt = textwrap.dedent("""\
318 
319        rewrite {
320            activeRecipe("com.azure.UpgradeBom")
321        }
322 
323        repositories {
324            mavenCentral()
325        }
326    """)
327    rewrite_block_groovy = rewrite_block_kt  # same syntax for both DSLs here
328 
329    plugins_pattern = re.compile(r"(plugins\s*\{)", re.MULTILINE)
330    match = plugins_pattern.search(content)
331    if match:
332        insert_pos = match.end()
333        # content[insert_pos:] already starts with the newline that follows
334        # `plugins {`, so don't add another one before the marker.
335        content = (
336            content[:insert_pos]
337            + "\n"
338            + GRADLE_PLUGIN_MARKER
339            + "\n"
340            + plugin_line
341            + content[insert_pos:]
342        )
343    else:
344        # No plugins block — prepend one
345        content = (
346            "plugins {\n"
347            + GRADLE_PLUGIN_MARKER
348            + "\n"
349            + plugin_line
350            + "\n}\n\n"
351            + content
352        )
353 
354    content += GRADLE_PLUGIN_MARKER + "\n"
355    content += rewrite_block_kt if kotlin else rewrite_block_groovy
356 
357    with open(build_file, "w", encoding="utf-8") as f:
358        f.write(content)
359    print(f"[upgrade_bom] Injected OpenRewrite plugin into {build_file}")
360    return True
361 
362 
363def _remove_gradle_rewrite_plugin(build_file: str) -> None:
364    """Remove the temporarily injected OpenRewrite plugin and config blocks."""
365    with open(build_file, "r", encoding="utf-8") as f:
366        lines = f.readlines()
367 
368    cleaned: list[str] = []
369    marker_count = 0
370    i = 0
371    while i < len(lines):
372        line = lines[i]
373        if GRADLE_PLUGIN_MARKER in line:
374            marker_count += 1
375            if marker_count == 1:
376                # First marker (inside plugins {}): skip the marker line and
377                # the following injected plugin id line.
378                i += 2
379                continue
380            else:
381                # Second marker (at end of file): skip the marker and every
382                # remaining line — they're the injected rewrite {} and
383                # repositories {} blocks.
384                break
385        cleaned.append(line)
386        i += 1
387 
388    with open(build_file, "w", encoding="utf-8") as f:
389        f.writelines(cleaned)
390    print(f"[upgrade_bom] Cleaned up OpenRewrite plugin from {build_file}")
391 
392 
393def _run_gradle_openrewrite(gradle_cmd: str, project_dir: str) -> int:
394    cmd = [gradle_cmd, "rewriteRun"]
395    print(f"[upgrade_bom] Running: {' '.join(cmd)}")
396    return subprocess.run(cmd, cwd=project_dir).returncode
397 
398 
399def _handle_gradle(project_dir: str, bom_version: str, gradle_cmd: str | None) -> int:
400    build_file = _find_gradle_build_file(project_dir)
401    if build_file is None:
402        print("[upgrade_bom] ERROR: no build.gradle or build.gradle.kts found", file=sys.stderr)
403        return 1
404 
405    gradle = gradle_cmd or _detect_gradle(project_dir)
406    has_bom = _has_gradle_bom_entry(build_file)
407 
408    if has_bom:
409        print(f"[upgrade_bom] Existing azure-sdk-bom entry found — upgrading to {bom_version}.")
410    else:
411        print("[upgrade_bom] No existing azure-sdk-bom entry found — adding via AddPlatformDependency.")
412 
413    yml_path = None
414    injected = False
415 
416    try:
417        # Set up OpenRewrite: create rewrite.yml + inject plugin temporarily
418        yml_path = _create_rewrite_yml(project_dir, bom_version, has_bom=has_bom)
419        injected = _inject_gradle_rewrite_plugin(build_file)
420        rc = _run_gradle_openrewrite(gradle, project_dir)
421    finally:
422        if yml_path and os.path.isfile(yml_path):
423            os.remove(yml_path)
424            print(f"[upgrade_bom] Removed {yml_path}")
425        if injected:
426            _remove_gradle_rewrite_plugin(build_file)
427 
428    if rc != 0:
429        print(f"[upgrade_bom] ERROR: OpenRewrite exited with code {rc}", file=sys.stderr)
430    else:
431        print(f"[upgrade_bom] BOM set to {bom_version} and redundant versions removed successfully.")
432    return rc
433 
434 
435# ---------------------------------------------------------------------------
436# Main
437# ---------------------------------------------------------------------------
438 
439def main(argv: list[str] | None = None) -> int:
440    parser = argparse.ArgumentParser(
441        description="Upgrade azure-sdk-bom version in a Maven or Gradle project using OpenRewrite."
442    )
443    parser.add_argument("project_dir", nargs="?", help="Path to the project root.")
444    parser.add_argument(
445        "bom_version",
446        nargs="?",
447        help="Target azure-sdk-bom version to apply. Resolve the latest stable version first.",
448    )
449    parser.add_argument("--mvn", default=None, help="Maven command override.")
450    parser.add_argument("--gradle", default=None, help="Gradle command override.")
451    parser.add_argument(
452        "--get-latest-version",
453        action="store_true",
454        help="Print the latest azure-sdk-bom version from the Azure SDK for Java BOM pom.xml.",
455    )
456    args = parser.parse_args(argv)
457 
458    if args.get_latest_version:
459        if args.project_dir or args.bom_version:
460            parser.error("--get-latest-version does not accept project_dir or bom_version.")
461        print(_get_latest_bom_version())
462        return 0
463 
464    if not args.project_dir or not args.bom_version:
465        parser.error("project_dir and bom_version are required unless --get-latest-version is used.")
466 
467    project_dir = os.path.abspath(args.project_dir)
468    build_system = _detect_build_system(project_dir)
469 
470    if build_system == "maven":
471        print("[upgrade_bom] Detected Maven project.")
472        return _handle_maven(project_dir, args.bom_version, args.mvn)
473    elif build_system == "gradle":
474        print("[upgrade_bom] Detected Gradle project.")
475        return _handle_gradle(project_dir, args.bom_version, args.gradle)
476    else:
477        print(
478            f"[upgrade_bom] ERROR: No pom.xml or build.gradle found in {project_dir}",
479            file=sys.stderr,
480        )
481        return 1
482 
483 
484if __name__ == "__main__":
485    sys.exit(main())
486