Hello Jacques, Please give me some time. I will look at your request/email and revert back soon.
Thank you, Ashish On Mon, 27 Jul 2026 at 15:41, Jacques Le Roux via dev <[email protected]> wrote: > Hi, > > Nobody care about licences? > > TIA > > Jacques > > Le 20/07/2026 à 11:51, Jacques Le Roux via dev a écrit : > > Hi Ashish, > > > > I Just had a look at > https://nightlies.apache.org/ofbiz/trunk/rat-output.html > > > > Actually IMO there is more than gradle.lockfile. > > I don't think a LICENSE file there is necessary .It's the only plugin > with it, since there is already one LICENSE file at plugins root. Same for > > framework an applis. > > For README.md there is no Apache license in top. It's not mandatory > since it's in rat-excludes.txt (tools repo). Some README.md have an Apache > > license inside. > > Though I added this linethat in rat-excludes.txt in 2017, I wonder now > if we should not remove this line and add the Apache license inside all > > README.md. > > > > What do you (and people at large) think? > > > > TIA > > > > Jacques > > > > Le 10/07/2026 à 15:46, [email protected] a écrit : > >> This is an automated email from the ASF dual-hosted git repository. > >> > >> ashishvijaywargiya pushed a commit to branch trunk > >> in repositoryhttps://gitbox.apache.org/repos/asf/ofbiz-plugins.git > >> > >> > >> The following commit(s) were added to refs/heads/trunk by this push: > >> new fe1a266d6 Add devreload plugin inside plugins directory (#316) > >> fe1a266d6 is described below > >> > >> commit fe1a266d60425b3b73469f185cb68bc27012495d > >> Author: Ashish Vijaywargiya<[email protected]> > >> AuthorDate: Fri Jul 10 19:16:19 2026 +0530 > >> > >> Add devreload plugin inside plugins directory (#316) > >> devreload plugin will give us option to work in Java > files(events and > >> services) and services.xml files without restarting ofbiz. > >> --- > >> devreload/LICENSE | 201 +++++ > >> devreload/README.md | 56 ++ > >> devreload/build.gradle | 187 +++++ > >> devreload/gradle.lockfile | 4 + > >> devreload/ofbiz-component.xml | 30 + > >> .../apache/ofbiz/devreload/DevReloadContainer.java | 860 > +++++++++++++++++++++ > >> .../org/apache/ofbiz/devreload/HotSwapAgent.java | 109 +++ > >> 7 files changed, 1447 insertions(+) > >> > >> diff --git a/devreload/LICENSE b/devreload/LICENSE > >> new file mode 100644 > >> index 000000000..261eeb9e9 > >> --- /dev/null > >> +++ b/devreload/LICENSE > >> @@ -0,0 +1,201 @@ > >> + Apache License > >> + Version 2.0, January 2004 > >> +http://www.apache.org/licenses/ > >> + > >> + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION > >> + > >> + 1. Definitions. > >> + > >> + "License" shall mean the terms and conditions for use, > reproduction, > >> + and distribution as defined by Sections 1 through 9 of this > document. > >> + > >> + "Licensor" shall mean the copyright owner or entity authorized by > >> + the copyright owner that is granting the License. > >> + > >> + "Legal Entity" shall mean the union of the acting entity and all > >> + other entities that control, are controlled by, or are under > common > >> + control with that entity. For the purposes of this definition, > >> + "control" means (i) the power, direct or indirect, to cause the > >> + direction or management of such entity, whether by contract or > >> + otherwise, or (ii) ownership of fifty percent (50%) or more of > the > >> + outstanding shares, or (iii) beneficial ownership of such entity. > >> + > >> + "You" (or "Your") shall mean an individual or Legal Entity > >> + exercising permissions granted by this License. > >> + > >> + "Source" form shall mean the preferred form for making > modifications, > >> + including but not limited to software source code, documentation > >> + source, and configuration files. > >> + > >> + "Object" form shall mean any form resulting from mechanical > >> + transformation or translation of a Source form, including but > >> + not limited to compiled object code, generated documentation, > >> + and conversions to other media types. > >> + > >> + "Work" shall mean the work of authorship, whether in Source or > >> + Object form, made available under the License, as indicated by a > >> + copyright notice that is included in or attached to the work > >> + (an example is provided in the Appendix below). > >> + > >> + "Derivative Works" shall mean any work, whether in Source or > Object > >> + form, that is based on (or derived from) the Work and for which > the > >> + editorial revisions, annotations, elaborations, or other > modifications > >> + represent, as a whole, an original work of authorship. For the > purposes > >> + of this License, Derivative Works shall not include works that > remain > >> + separable from, or merely link (or bind by name) to the > interfaces of, > >> + the Work and Derivative Works thereof. > >> + > >> + "Contribution" shall mean any work of authorship, including > >> + the original version of the Work and any modifications or > additions > >> + to that Work or Derivative Works thereof, that is intentionally > >> + submitted to Licensor for inclusion in the Work by the copyright > owner > >> + or by an individual or Legal Entity authorized to submit on > behalf of > >> + the copyright owner. For the purposes of this definition, > "submitted" > >> + means any form of electronic, verbal, or written communication > sent > >> + to the Licensor or its representatives, including but not > limited to > >> + communication on electronic mailing lists, source code control > systems, > >> + and issue tracking systems that are managed by, or on behalf of, > the > >> + Licensor for the purpose of discussing and improving the Work, > but > >> + excluding communication that is conspicuously marked or otherwise > >> + designated in writing by the copyright owner as "Not a > Contribution." > >> + > >> + "Contributor" shall mean Licensor and any individual or Legal > Entity > >> + on behalf of whom a Contribution has been received by Licensor > and > >> + subsequently incorporated within the Work. > >> + > >> + 2. Grant of Copyright License. Subject to the terms and conditions > of > >> + this License, each Contributor hereby grants to You a perpetual, > >> + worldwide, non-exclusive, no-charge, royalty-free, irrevocable > >> + copyright license to reproduce, prepare Derivative Works of, > >> + publicly display, publicly perform, sublicense, and distribute > the > >> + Work and such Derivative Works in Source or Object form. > >> + > >> + 3. Grant of Patent License. Subject to the terms and conditions of > >> + this License, each Contributor hereby grants to You a perpetual, > >> + worldwide, non-exclusive, no-charge, royalty-free, irrevocable > >> + (except as stated in this section) patent license to make, have > made, > >> + use, offer to sell, sell, import, and otherwise transfer the > Work, > >> + where such license applies only to those patent claims licensable > >> + by such Contributor that are necessarily infringed by their > >> + Contribution(s) alone or by combination of their Contribution(s) > >> + with the Work to which such Contribution(s) was submitted. If You > >> + institute patent litigation against any entity (including a > >> + cross-claim or counterclaim in a lawsuit) alleging that the Work > >> + or a Contribution incorporated within the Work constitutes direct > >> + or contributory patent infringement, then any patent licenses > >> + granted to You under this License for that Work shall terminate > >> + as of the date such litigation is filed. > >> + > >> + 4. Redistribution. You may reproduce and distribute copies of the > >> + Work or Derivative Works thereof in any medium, with or without > >> + modifications, and in Source or Object form, provided that You > >> + meet the following conditions: > >> + > >> + (a) You must give any other recipients of the Work or > >> + Derivative Works a copy of this License; and > >> + > >> + (b) You must cause any modified files to carry prominent notices > >> + stating that You changed the files; and > >> + > >> + (c) You must retain, in the Source form of any Derivative Works > >> + that You distribute, all copyright, patent, trademark, and > >> + attribution notices from the Source form of the Work, > >> + excluding those notices that do not pertain to any part of > >> + the Derivative Works; and > >> + > >> + (d) If the Work includes a "NOTICE" text file as part of its > >> + distribution, then any Derivative Works that You distribute > must > >> + include a readable copy of the attribution notices contained > >> + within such NOTICE file, excluding those notices that do not > >> + pertain to any part of the Derivative Works, in at least one > >> + of the following places: within a NOTICE text file > distributed > >> + as part of the Derivative Works; within the Source form or > >> + documentation, if provided along with the Derivative Works; > or, > >> + within a display generated by the Derivative Works, if and > >> + wherever such third-party notices normally appear. The > contents > >> + of the NOTICE file are for informational purposes only and > >> + do not modify the License. You may add Your own attribution > >> + notices within Derivative Works that You distribute, > alongside > >> + or as an addendum to the NOTICE text from the Work, provided > >> + that such additional attribution notices cannot be construed > >> + as modifying the License. > >> + > >> + You may add Your own copyright statement to Your modifications > and > >> + may provide additional or different license terms and conditions > >> + for use, reproduction, or distribution of Your modifications, or > >> + for any such Derivative Works as a whole, provided Your use, > >> + reproduction, and distribution of the Work otherwise complies > with > >> + the conditions stated in this License. > >> + > >> + 5. Submission of Contributions. Unless You explicitly state > otherwise, > >> + any Contribution intentionally submitted for inclusion in the > Work > >> + by You to the Licensor shall be under the terms and conditions of > >> + this License, without any additional terms or conditions. > >> + Notwithstanding the above, nothing herein shall supersede or > modify > >> + the terms of any separate license agreement you may have executed > >> + with Licensor regarding such Contributions. > >> + > >> + 6. Trademarks. This License does not grant permission to use the > trade > >> + names, trademarks, service marks, or product names of the > Licensor, > >> + except as required for reasonable and customary use in > describing the > >> + origin of the Work and reproducing the content of the NOTICE > file. > >> + > >> + 7. Disclaimer of Warranty. Unless required by applicable law or > >> + agreed to in writing, Licensor provides the Work (and each > >> + Contributor provides its Contributions) on an "AS IS" BASIS, > >> + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or > >> + implied, including, without limitation, any warranties or > conditions > >> + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A > >> + PARTICULAR PURPOSE. You are solely responsible for determining > the > >> + appropriateness of using or redistributing the Work and assume > any > >> + risks associated with Your exercise of permissions under this > License. > >> + > >> + 8. Limitation of Liability. In no event and under no legal theory, > >> + whether in tort (including negligence), contract, or otherwise, > >> + unless required by applicable law (such as deliberate and grossly > >> + negligent acts) or agreed to in writing, shall any Contributor be > >> + liable to You for damages, including any direct, indirect, > special, > >> + incidental, or consequential damages of any character arising as > a > >> + result of this License or out of the use or inability to use the > >> + Work (including but not limited to damages for loss of goodwill, > >> + work stoppage, computer failure or malfunction, or any and all > >> + other commercial damages or losses), even if such Contributor > >> + has been advised of the possibility of such damages. > >> + > >> + 9. Accepting Warranty or Additional Liability. While redistributing > >> + the Work or Derivative Works thereof, You may choose to offer, > >> + and charge a fee for, acceptance of support, warranty, indemnity, > >> + or other liability obligations and/or rights consistent with this > >> + License. However, in accepting such obligations, You may act only > >> + on Your own behalf and on Your sole responsibility, not on behalf > >> + of any other Contributor, and only if You agree to indemnify, > >> + defend, and hold each Contributor harmless for any liability > >> + incurred by, or claims asserted against, such Contributor by > reason > >> + of your accepting any such warranty or additional liability. > >> + > >> + END OF TERMS AND CONDITIONS > >> + > >> + APPENDIX: How to apply the Apache License to your work. > >> + > >> + To apply the Apache License to your work, attach the following > >> + boilerplate notice, with the fields enclosed by brackets "[]" > >> + replaced with your own identifying information. (Don't include > >> + the brackets!) The text should be enclosed in the appropriate > >> + comment syntax for the file format. We also recommend that a > >> + file or class name and description of purpose be included on the > >> + same "printed page" as the copyright notice for easier > >> + identification within third-party archives. > >> + > >> + Copyright [yyyy] [name of copyright owner] > >> + > >> + Licensed under the Apache License, Version 2.0 (the "License"); > >> + you may not use this file except in compliance with the License. > >> + You may obtain a copy of the License at > >> + > >> +http://www.apache.org/licenses/LICENSE-2.0 > >> + > >> + Unless required by applicable law or agreed to in writing, software > >> + distributed under the License is distributed on an "AS IS" BASIS, > >> + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or > implied. > >> + See the License for the specific language governing permissions and > >> + limitations under the License. > >> diff --git a/devreload/README.md b/devreload/README.md > >> new file mode 100644 > >> index 000000000..246d9495c > >> --- /dev/null > >> +++ b/devreload/README.md > >> @@ -0,0 +1,56 @@ > >> +# devreload > >> + > >> +Development-only hot-reload for OFBiz. Edit a Java service/event > method, a > >> +`services.xml` file, or add a brand-new method, and the change is live > in under a > >> +second — no restart, ever. > >> + > >> +The plugin is entirely self-contained: dropping this directory into a > checkout (or > >> +removing it) has zero effect on the rest of OFBiz either way. > >> + > >> +## Requirements > >> + > >> +This plugin needs a **DCEVM (Dynamic Code Evolution Virtual Machine)** > JVM to run. > >> +Set it up once, before running `./gradlew ofbizDev --no-watch-fs`: > >> + > >> +1. Get a DCEVM-patched JVM. Easiest source: JetBrains Runtime (JBR), > bundled with > >> + IntelliJ IDEA under `<IDE install>/jbr` (`.../Contents/jbr` on > macOS). Standalone > >> + DCEVM builds work too. > >> +2. Point at it — set the `DCEVM_HOME` env var (e.g. in your shell > profile) so every > >> + future run picks it up automatically, or pass > `-PdcevmHome=/path/to/jvm` each time > >> + instead. > >> + > >> +Add this to your shell profile (`~/.zshrc`, `~/.bashrc`, etc.) so it's > always set: > >> + > >> +``` > >> +export DCEVM_HOME="/Applications/IntelliJ IDEA.app/Contents/jbr" > >> +``` > >> + > >> +(adjust the path to wherever your DCEVM-patched JVM lives — on macOS > this is IntelliJ's > >> +bundled JetBrains Runtime by default). Reload your shell (or run > `source ~/.zshrc`) and > >> +every future `./gradlew ofbizDev --no-watch-fs` picks it up > automatically, with nothing > >> +else to set. > >> + > >> +## Usage > >> + > >> +``` > >> +./gradlew ofbizDev --no-watch-fs > >> +``` > >> + > >> +This is the only supported command — always run it exactly like this. > It boots OFBiz > >> +and everything hot-swaps live, no restart: method-body edits, > `services.xml` changes, > >> +and structural changes (new/removed methods or fields, changed > signatures) alike. > >> + > >> +`--no-watch-fs` disables Gradle's own file-system watching, which > otherwise competes > >> +with this plugin's `WatchService` for the same macOS per-process > directory-watch > >> +ceiling on a full checkout — without it, some directories can silently > go unwatched. > >> +It's harmless to include even on a smaller/scoped checkout, so it's > part of the one > >> +command to remember. > >> + > >> +If DCEVM isn't set up, it fails immediately — before compiling or > booting anything — > >> +with the same setup steps as above. > >> + > >> +Scope to specific components for a faster startup: > >> + > >> +``` > >> +./gradlew ofbizDev --no-watch-fs -Photreload.components=devreload,party > >> +``` > >> diff --git a/devreload/build.gradle b/devreload/build.gradle > >> new file mode 100644 > >> index 000000000..148fcb902 > >> --- /dev/null > >> +++ b/devreload/build.gradle > >> @@ -0,0 +1,187 @@ > >> +/* > >> + * Licensed to the Apache Software Foundation (ASF) under one > >> + * or more contributor license agreements. See the NOTICE file > >> + * distributed with this work for additional information > >> + * regarding copyright ownership. The ASF licenses this file > >> + * to you under the Apache License, Version 2.0 (the > >> + * "License"); you may not use this file except in compliance > >> + * with the License. You may obtain a copy of the License at > >> + * > >> + *http://www.apache.org/licenses/LICENSE-2.0 > >> + * > >> + * Unless required by applicable law or agreed to in writing, > >> + * software distributed under the License is distributed on an > >> + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY > >> + * KIND, either express or implied. See the License for the > >> + * specific language governing permissions and limitations > >> + * under the License. > >> + */ > >> + > >> +// Optional -Photreload.components=compA,compB, forwarded as > >> +// -Dofbiz.hotreload.components to DevReloadContainer, which then only > watches those > >> +// components' servicedef/source directories instead of every > component in the checkout. > >> +// See DevReloadContainer's `allowedComponents` javadoc for why: > macOS's WatchService has > >> +// a practical per-process ceiling on watched directories well under a > typical ulimit, > >> +// and a checkout the size of OFBiz trunk (~50+ components) can exceed > it. > >> +static List<String> hotreloadComponentArgs(Project project) { > >> + String components = project.findProperty('hotreload.components') > >> + return components ? > ["-Dofbiz.hotreload.components=${components}".toString()] : [] > >> +} > >> + > >> +// Optional -Photreload.watchBuildOutput=true, forwarded as > >> +// -Dofbiz.hotreload.watchBuildOutput to DevReloadContainer. Off by > default: watching > >> +// build/classes/java/main only matters for picking up > externally-produced .class files > >> +// (e.g. `./gradlew -t classes` running in a second terminal) -- > in-process compiles hot-swap > >> +// directly and never need it -- and unlike source/servicedef > watching, that tree isn't > >> +// narrowed by -Photreload.components, so on a full checkout it > roughly doubles the total > >> +// directories watched for no benefit to the common (in-process-only) > workflow. > >> +static List<String> hotreloadWatchBuildOutputArgs(Project project) { > >> + Object watchBuildOutput = > project.findProperty('hotreload.watchBuildOutput') > >> + return watchBuildOutput ? > ["-Dofbiz.hotreload.watchBuildOutput=${watchBuildOutput}".toString()] : [] > >> +} > >> + > >> +// DevReloadContainer's own in-process-compile output directory. > Deliberately separate > >> +// from Gradle's own build/classes/java/main (see DevReloadContainer's > hotReloadOutputDir > >> +// field javadoc for why) and placed ahead of the normal runtime > classpath below, so a > >> +// class compiled here but never yet loaded in the running JVM picks > up the live version > >> +// on its first load too, not just already-loaded ones. Passed down to > the JVM as a system > >> +// property (see commonHotReloadJvmArgs) rather than hardcoded > independently on the Java > >> +// side too, so this path exists as a single source of truth. > >> +static File hotReloadOutputDir(Project project) { > >> + return new File(project.rootDir, 'build/devreload/classes') > >> +} > >> + > >> +// Base JVM args for ofbizDev: the hot-reload activation flags, the > output-directory > >> +// location, and the optional component/watch scoping args. > >> +// -XX:+AllowEnhancedClassRedefinition is added separately by the > caller, once a > >> +// DCEVM-patched JVM has actually been resolved (required -- see > below). > >> +static List<String> commonHotReloadJvmArgs(Project project) { > >> + List<String> args = ['-Dofbiz.hotreload=true', > '-Djdk.attach.allowAttachSelf=true', > >> + > "-Dofbiz.hotreload.outputDir=${hotReloadOutputDir(project).absolutePath}".toString()] > >> + args += hotreloadComponentArgs(project) > >> + args += hotreloadWatchBuildOutputArgs(project) > >> + return args > >> +} > >> + > >> +// Locates a DCEVM-patched `java` executable from an explicit > -PdcevmHome=... or > >> +// DCEVM_HOME env var -- deliberately not auto-detected by guessing > per-OS IDE install > >> +// paths (IntelliJ's JBR bundles DCEVM and is a convenient source of > one, but its > >> +// install location varies too much across OS/Toolbox/version to guess > reliably). One > >> +// explicit way in is easier to reason about, document, and keep > working than several > >> +// silent path guesses that can each go stale independently. > `ofbizDev` below requires > >> +// this to resolve to something -- it fails fast with setup > instructions otherwise. > >> +// > >> +// Two ways to set it once and forget it, so every future plain > `./gradlew ofbizDev` > >> +// just works with no flag: export DCEVM_HOME in a shell profile > (picked up via > >> +// System.getenv() below), or add a `dcevmHome=/path/to/jvm` line to > >> +// `~/.gradle/gradle.properties` (GRADLE_USER_HOME -- picked up via > project.findProperty() > >> +// below, same as -PdcevmHome on the command line, just persisted > instead of retyped). > >> +// The latter needs the Gradle property name `dcevmHome`, not > `DCEVM_HOME` -- gradle.properties > >> +// holds Gradle properties, not env vars, so the two names aren't > interchangeable there. > >> +def resolveDcevmJavaExecutable = { > >> + String home = project.findProperty('dcevmHome') ?: > System.getenv('DCEVM_HOME') > >> + if (!home) { > >> + return null > >> + } > >> + String exeName = > org.gradle.internal.os.OperatingSystem.current().isWindows() ? 'java.exe' : > 'java' > >> + File exe = new File(home, "bin/${exeName}") > >> + if (!exe.exists()) { > >> + // macOS JDK/JBR app bundles nest an extra Contents/Home -- > e.g. IntelliJ's bundled > >> + // JetBrains Runtime lives at "<IDE > install>/Contents/jbr/Contents/Home/bin/java", > >> + // one level deeper than the jbr folder itself (which is what > README/error-message > >> + // guidance points DCEVM_HOME/-PdcevmHome at). Fall back to > that layout before > >> + // giving up, so the documented "point at <IDE > install>/Contents/jbr" guidance > >> + // actually resolves on macOS instead of silently finding > nothing. > >> + exe = new File(home, "Contents/Home/bin/${exeName}") > >> + } > >> + return exe.exists() ? exe.absolutePath : null > >> +} > >> + > >> +// Convenience task: `./gradlew ofbizDev` starts OFBiz with hot-reload > enabled > >> +// (-Dofbiz.hotreload=true), plus the JVM flag DevReloadContainer's > self-attaching > >> +// HotSwapAgent needs (-Djdk.attach.allowAttachSelf=true). Registered > on the root > >> +// project, mirroring the classpath/mainClass wiring of the built-in > `ofbiz` command > >> +// task, so this plugin needs no change to the root build.gradle to be > usable. > >> +// > >> +// A DCEVM-patched JVM is required, not optional: stock-JDK hot-reload > used to be a > >> +// supported fallback, but a stock JVM's redefineClasses can't > hot-swap a new/removed > >> +// method or field anyway (see DevReloadContainer's class-level > javadoc), so silently > >> +// running in that degraded mode just defers the surprise to whenever > someone adds a > >> +// method. Simple by design: if DCEVM_HOME/-PdcevmHome resolves to a > real JVM, this task > >> +// just runs -- no other flag, no mode to pick. If it doesn't resolve, > running `ofbizDev` > >> +// fails immediately with setup instructions, before OFBiz attempts to > boot -- but the > >> +// failure has to be raised from a doFirst task action, not directly > in this > >> +// configuration block: this block runs whenever the project is > evaluated, which in this > >> +// build happens on every `./gradlew <anything>` invocation, not just > when `ofbizDev` > >> +// itself is requested (confirmed empirically -- even `./gradlew help` > realizes this > >> +// task, most likely because the Develocity plugin applied in > settings.gradle touches > >> +// every registered task for build-scan data). Throwing here > unconditionally would break > >> +// every Gradle command whenever DCEVM isn't set up, which is exactly > the "zero effect on > >> +// anyone not using it" guarantee this plugin promises everywhere else > (see README). > >> +// > >> +// JavaExec's `executable` property is pointed at the resolved DCEVM > JVM binary during > >> +// task configuration -- no toolchain is configured anywhere in this > project for that to > >> +// conflict with. One non-obvious wrinkle: `executable` has to be set > directly in the > >> +// task's configuration block, not from a task action (e.g. inside > doFirst). Doing it > >> +// from a task action fails with "Toolchain from executable property > does not match > >> +// toolchain from javaLauncher property" -- by the time a task action > runs, javaLauncher's > >> +// convention has already been finalized for execution, and overriding > executable at that > >> +// point conflicts with it. Setting it during configuration, before > that convention > >> +// finalizes, works cleanly. That's also *why* the DCEVM lookup itself > still has to happen > >> +// eagerly in this block (only the throw is deferred to doFirst): > `executable` can't be > >> +// set any later. > >> +rootProject.tasks.register('ofbizDev', JavaExec) { > >> + group = 'OFBiz Server Commands' > >> + description = 'Start OFBiz with hot-reload (requires a > DCEVM-patched JVM -- see README). Java source, ' + > >> + 'services.xml, and structural changes (new/removed methods > or fields, changed signatures) all ' + > >> + 'reload live with no restart. Point > -PdcevmHome=/path/to/jvm or set DCEVM_HOME to enable; fails ' + > >> + 'fast with setup instructions if neither resolves. > Optionally scope to specific components with ' + > >> + '-Photreload.components=compA,compB, or watch > build/classes/java/main too (for externally-produced ' + > >> + '.class files) with -Photreload.watchBuildOutput=true.' > >> + classpath = rootProject.files(hotReloadOutputDir(project)) + > rootProject.sourceSets.main.runtimeClasspath > >> + mainClass = rootProject.application.mainClass > >> + List<String> jvmArgsList = > rootProject.application.applicationDefaultJvmArgs + > commonHotReloadJvmArgs(project) > >> + String dcevmJava = resolveDcevmJavaExecutable() > >> + if (dcevmJava) { > >> + // Only wired up when actually needed: compiling everything > first just to fail in > >> + // doFirst afterwards would make the "no DCEVM" error slow to > reach on a cold build. > >> + dependsOn rootProject.tasks.named('classes') > >> + jvmArgsList = jvmArgsList + > ['-XX:+AllowEnhancedClassRedefinition'] > >> + logger.lifecycle("ofbizDev: DCEVM-patched JVM resolved at > ${dcevmJava}") > >> + executable = dcevmJava > >> + } else { > >> + // Deferred to a task action (doFirst) instead of thrown > directly here: this > >> + // configuration block runs whenever this project is > evaluated, which in this build > >> + // happens for every `./gradlew <anything>` invocation, not > just when `ofbizDev` > >> + // itself is requested (confirmed empirically -- even > `./gradlew help` realizes this > >> + // task's configuration block, most likely due to the > Develocity plugin applied in > >> + // settings.gradle touching every registered task for > build-scan data). Throwing here > >> + // directly would break every Gradle command whenever DCEVM > isn't set up, violating > >> + // this plugin's "zero effect on anyone not using it" > guarantee (see README). A > >> + // doFirst block, by contrast, only actually runs when > `ofbizDev` is the task Gradle > >> + // is executing. > >> + String attemptedHome = project.findProperty('dcevmHome') ?: > System.getenv('DCEVM_HOME') > >> + String detail = attemptedHome > >> + ? "DCEVM_HOME/-PdcevmHome is set to > '${attemptedHome}', but no 'bin/java' (or macOS " + > >> + "'Contents/Home/bin/java') was found there -- > double-check the path." > >> + : "Neither -PdcevmHome nor the DCEVM_HOME env var is > set." > >> + doFirst { > >> + throw new GradleException( > >> + "ofbizDev requires a DCEVM-patched JVM -- plain > stock-JDK hot-reload is not supported.\n\n" + > >> + "${detail}\n\n" + > >> + "To fix this:\n" + > >> + " 1. Get a DCEVM-patched JVM. The easiest source > is JetBrains Runtime (JBR), which " + > >> + "bundles DCEVM and ships with IntelliJ IDEA under > '<IDE install>/jbr' " + > >> + "('.../Contents/jbr' on macOS). Standalone DCEVM > builds work too.\n" + > >> + " 2. Point at it -- set the DCEVM_HOME env var > once (e.g. in your shell profile, so " + > >> + "every future run picks it up automatically) or > pass -PdcevmHome=/path/to/jvm each " + > >> + "time.\n\n" + > >> + "See plugins/devreload/README.md for the full > setup guide.") > >> + } > >> + } > >> + jvmArgs(jvmArgsList) > >> +} > >> + > >> +dependencyLocking { > >> + lockAllConfigurations() > >> +} > >> diff --git a/devreload/gradle.lockfile b/devreload/gradle.lockfile > >> new file mode 100644 > >> index 000000000..b9b85588a > >> --- /dev/null > >> +++ b/devreload/gradle.lockfile > >> @@ -0,0 +1,4 @@ > >> +# This is a Gradle generated file for dependency locking. > >> +# Manual edits can break the build and are not advised. > >> +# This file is expected to be part of source control. > >> +empty=pluginLibsCompile,pluginLibsCompileOnly,pluginLibsRuntime > >> diff --git a/devreload/ofbiz-component.xml > b/devreload/ofbiz-component.xml > >> new file mode 100644 > >> index 000000000..c9ecab1fb > >> --- /dev/null > >> +++ b/devreload/ofbiz-component.xml > >> @@ -0,0 +1,30 @@ > >> +<?xml version="1.0" encoding="UTF-8"?> > >> +<!-- > >> +Licensed to the Apache Software Foundation (ASF) under one > >> +or more contributor license agreements. See the NOTICE file > >> +distributed with this work for additional information > >> +regarding copyright ownership. The ASF licenses this file > >> +to you under the Apache License, Version 2.0 (the > >> +"License"); you may not use this file except in compliance > >> +with the License. You may obtain a copy of the License at > >> + > >> +http://www.apache.org/licenses/LICENSE-2.0 > >> + > >> +Unless required by applicable law or agreed to in writing, > >> +software distributed under the License is distributed on an > >> +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY > >> +KIND, either express or implied. See the License for the > >> +specific language governing permissions and limitations > >> +under the License. > >> +--> > >> + > >> +<ofbiz-component name="devreload" enabled="true" > >> + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; > >> + xsi:noNamespaceSchemaLocation=" > https://ofbiz.apache.org/dtds/ofbiz-component.xsd";> > >> + <resource-loader name="main" type="component"/> > >> + > >> + <!-- Development hot-reload container: a no-op unless started with > >> + -Dofbiz.hotreload=true, so it is safe to leave enabled in > every > >> + environment. See README.md for usage. --> > >> + <container name="dev-reload-container" loaders="main" > class="org.apache.ofbiz.devreload.DevReloadContainer"/> > >> +</ofbiz-component> > >> diff --git > a/devreload/src/main/java/org/apache/ofbiz/devreload/DevReloadContainer.java > > >> > b/devreload/src/main/java/org/apache/ofbiz/devreload/DevReloadContainer.java > >> new file mode 100644 > >> index 000000000..1f9539cb2 > >> --- /dev/null > >> +++ > b/devreload/src/main/java/org/apache/ofbiz/devreload/DevReloadContainer.java > >> @@ -0,0 +1,860 @@ > >> > +/******************************************************************************* > >> + * Licensed to the Apache Software Foundation (ASF) under one > >> + * or more contributor license agreements. See the NOTICE file > >> + * distributed with this work for additional information > >> + * regarding copyright ownership. The ASF licenses this file > >> + * to you under the Apache License, Version 2.0 (the > >> + * "License"); you may not use this file except in compliance > >> + * with the License. You may obtain a copy of the License at > >> + * > >> + *http://www.apache.org/licenses/LICENSE-2.0 > >> + * > >> + * Unless required by applicable law or agreed to in writing, > >> + * software distributed under the License is distributed on an > >> + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY > >> + * KIND, either express or implied. See the License for the > >> + * specific language governing permissions and limitations > >> + * under the License. > >> + > *******************************************************************************/ > >> +package org.apache.ofbiz.devreload; > >> + > >> +import java.io.IOException; > >> +import java.lang.instrument.ClassDefinition; > >> +import java.lang.instrument.Instrumentation; > >> +import java.lang.management.ManagementFactory; > >> +import java.net.URI; > >> +import java.net.URISyntaxException; > >> +import java.net.URL; > >> +import java.nio.file.ClosedWatchServiceException; > >> +import java.nio.file.FileVisitResult; > >> +import java.nio.file.Files; > >> +import java.nio.file.Path; > >> +import java.nio.file.Paths; > >> +import java.nio.file.SimpleFileVisitor; > >> +import java.nio.file.StandardWatchEventKinds; > >> +import java.nio.file.WatchEvent; > >> +import java.nio.file.WatchKey; > >> +import java.nio.file.WatchService; > >> +import java.nio.file.attribute.BasicFileAttributes; > >> +import java.util.ArrayList; > >> +import java.util.Arrays; > >> +import java.util.HashSet; > >> +import java.util.List; > >> +import java.util.Set; > >> +import java.util.concurrent.Executors; > >> +import java.util.concurrent.RejectedExecutionException; > >> +import java.util.concurrent.ScheduledExecutorService; > >> +import java.util.concurrent.ScheduledFuture; > >> +import java.util.concurrent.TimeUnit; > >> +import java.util.function.Consumer; > >> +import java.util.stream.Collectors; > >> +import javax.tools.JavaCompiler; > >> +import javax.tools.StandardJavaFileManager; > >> +import javax.tools.StandardLocation; > >> +import javax.tools.ToolProvider; > >> + > >> +import org.apache.commons.io.FileUtils; > >> +import org.apache.ofbiz.base.component.ComponentConfig; > >> +import org.apache.ofbiz.base.config.GenericConfigException; > >> +import org.apache.ofbiz.base.container.Container; > >> +import org.apache.ofbiz.base.container.ContainerException; > >> +import org.apache.ofbiz.base.start.StartupCommand; > >> +import org.apache.ofbiz.base.util.Debug; > >> +import org.apache.ofbiz.base.util.cache.UtilCache; > >> + > >> +/** > >> + * Development-only container that watches Java sources/classes and > {@code services.xml} > >> + * files and applies changes to a running OFBiz instance without a > restart. > >> + * > >> + * <h2>Activation</h2> > >> + * Add {@code -Dofbiz.hotreload=true > -Djdk.attach.allowAttachSelf=true} to your JVM > >> + * arguments, then start OFBiz normally (or run {@code ./gradlew > ofbizDev}, provided by > >> + * this plugin, which sets both automatically — the only supported > command). That Gradle > >> + * task requires a DCEVM-patched JVM and fails fast with setup > instructions if none is > >> + * resolvable; see "Structural changes" below for why. > >> + * > >> + * <h2>How Java hot-reload works</h2> > >> + * <ol> > >> + * <li>At startup this container self-attaches {@link HotSwapAgent} > to the current JVM > >> + * via the Attach API, obtaining a live {@link Instrumentation} > instance — no > >> + * {@code -javaagent} flag needed.</li> > >> + * <li>A {@link WatchService} thread monitors every component's > {@code src/main/java} > >> + * directory. On save, changed {@code .java} files are compiled > in-process (a JDK, > >> + * not just a JRE, is required) into {@code > build/devreload/classes/} — a directory > >> + * private to this plugin, deliberately <em>not</em> Gradle's own > >> + * {@code build/classes/java/main/}. Writing into Gradle's > managed output would > >> + * leave its incremental-build cache unaware of the change: if a > source file is > >> + * later reverted to content Gradle already has a snapshot for > (e.g. via > >> + * {@code git checkout}) while no hot-reload session is > watching, Gradle's next > >> + * {@code compileJava} would see matching input and skip > recompiling, silently > >> + * leaving the stale hot-swapped {@code .class} file in place. > This plugin's output > >> + * directory is cleared and recreated on every {@link #init}, so > a fresh run never > >> + * inherits a previous session's bytecode, and is placed ahead > of Gradle's own > >> + * output on the classpath (see {@code build.gradle}) so it > always wins when a class > >> + * exists in both places. Running {@code ./gradlew -t classes} > externally in a > >> + * second terminal still works — the same WatchService also > monitors Gradle's own > >> + * output directory directly for externally-produced {@code > .class} files, when > >> + * {@code -Dofbiz.hotreload.watchBuildOutput=true}.</li> > >> + * <li>Changes are debounced for 300 ms so a single compile run is > handled as one batch. > >> + * Each changed class already loaded in the JVM is updated in > place via > >> + * {@link Instrumentation#redefineClasses}, the same mechanism > an IDE debugger uses > >> + * for HotSwap. Because the {@link Class} object's identity > never changes, every > >> + * existing reference to it — including caches inside {@code > JavaEventHandler} and > >> + * {@code StandardJavaEngine} — automatically executes the new > method bodies on the > >> + * next call. No framework code needs to know this plugin > exists.</li> > >> + * <li>Brand-new classes need no special handling at all: they > simply get loaded > >> + * normally, from this plugin's build output directory, the > first time something > >> + * references them.</li> > >> + * </ol> > >> + * > >> + * <h2>Structural changes</h2> > >> + * On a stock JVM, {@code redefineClasses} can only replace method > bodies and static > >> + * initializers of a class that is already loaded — adding/removing > methods or fields, > >> + * changing a method signature, or changing the class hierarchy still > requires a restart. > >> + * This is a hard JVM limitation, not something this plugin can work > around on a stock > >> + * JVM. Running on a DCEVM-patched JVM with {@code > -XX:+AllowEnhancedClassRedefinition} > >> + * lifts that restriction transparently: this class calls the exact > same > >> + * {@code redefineClasses} API either way, so structural changes just > work when that flag > >> + * is present. Because a stock JVM would silently defer that surprise > to whenever someone > >> + * adds a method, {@code ./gradlew ofbizDev}'s build.gradle task > treats a DCEVM-patched > >> + * JVM as required, not optional: it resolves one via {@code > -PdcevmHome}/ > >> + * {@code DCEVM_HOME}, launches with that flag automatically, and > fails fast with setup > >> + * instructions instead of starting OFBiz at all if none is > resolvable. Plain stock-JDK > >> + * operation is not a supported outcome of that command. > >> + * > >> + * <h2>How services.xml changes are handled</h2> > >> + * Every component's {@code servicedef/} directory is also watched; on > change, the > >> + * {@code service.ModelServiceMapByModel} {@link UtilCache} entry is > cleared directly, so > >> + * the new/edited definition is re-read on the next service call. > >> + * > >> + * <h2>Directory watch limits</h2> > >> + * The OS may refuse to watch a directory once a process-wide ceiling > is reached (most > >> + * commonly hit on macOS on a full checkout). This container does not > try to work around > >> + * that itself: a directory whose registration fails is simply left > unwatched, with a > >> + * warning naming it, rather than silently falling back to some slower > alternate > >> + * mechanism. Narrow the set of directories with {@code > -Dofbiz.hotreload.components} > >> + * (or {@code -Photreload.components=compA,compB} with the {@code > ofbizDev} Gradle task) > >> + * to fit under the ceiling — see this component's README for the full > guidance. > >> + * > >> + * <h2>Scope</h2> > >> + * This container is intentionally dev-only. It has no effect when the > system property is > >> + * absent, so it is safe to leave the registration in this component's > >> + * {@code ofbiz-component.xml} for all environments. > >> + */ > >> +public class DevReloadContainer implements Container { > >> + > >> + private static final String MODULE = > DevReloadContainer.class.getName(); > >> + private static final String SERVICE_MODEL_CACHE_NAME = > "service.ModelServiceMapByModel"; > >> + > >> + private String name; > >> + private WatchService watchService; > >> + private Thread watchThread; > >> + private ScheduledExecutorService debounceExecutor; > >> + private Instrumentation instrumentation; > >> + > >> + private final Debouncer<String> classReloadDebouncer = new > Debouncer<>(this::applyReload); > >> + private final Debouncer<Path> xmlReloadDebouncer = new > Debouncer<>(this::applyServiceXmlReload); > >> + private final Debouncer<Path> compileDebouncer = new > Debouncer<>(this::applyCompile); > >> + > >> + // Counts across > registerServicedefDirs()/registerSourceDirs()/registerAll(), so > >> + // start() can emit one aggregated warning instead of leaving > individual failures > >> + // scattered in the log where they're easy to miss. > >> + private int watchDirsAttempted = 0; > >> + private int watchDirsFailed = 0; > >> + > >> + /** Gradle's own compiled-output directory, {@code > build/classes/java/main}. Read-only > >> + * from this class's perspective: only ever watched (when {@code > watchBuildOutput} is > >> + * on) for externally-produced {@code .class} files, never > written to directly. */ > >> + private Path classesDir; > >> + > >> + /** > >> + * This plugin's own compiled-output directory, {@code > build/devreload/classes}, > >> + * deliberately separate from Gradle's {@link #classesDir}. > In-process compiles > >> + * (see {@link #applyCompile}) write here instead of into Gradle's > managed output, so > >> + * Gradle's incremental {@code compileJava} up-to-date check is > never confused by > >> + * writes it didn't make itself. Cleared and recreated fresh on > every {@link #init}, > >> + * and placed ahead of Gradle's output on the runtime classpath > (see > >> + * {@code plugins/devreload/build.gradle}) — so when a class > exists in both > >> + * directories, this one always wins (see {@link > #resolveClassFile}). > >> + */ > >> + private Path hotReloadOutputDir; > >> + > >> + // Populated in start() before the watch thread launches; > read-only after that. > >> + private final Set<Path> servicedefDirs = new HashSet<>(); > >> + private final Set<Path> sourceRootDirs = new HashSet<>(); > >> + > >> + /** > >> + * Component names to watch, from {@code > -Dofbiz.hotreload.components}; {@code null} > >> + * means watch every component. Set this property to a > comma-separated list of > >> + * component names to keep the total number of watched directories > under the OS's > >> + * per-process ceiling on a large checkout. > >> + */ > >> + private Set<String> allowedComponents; > >> + > >> + /** > >> + * Whether {@link #classesDir} ({@code build/classes/java/main}) > itself is watched, from > >> + * {@code -Dofbiz.hotreload.watchBuildOutput}; defaults to {@code > false}. This tree mirrors > >> + * every component's source tree and, unlike {@link > #sourceRootDirs}, is <em>not</em> > >> + * narrowed by {@link #allowedComponents} (compiled output isn't > organized per component), > >> + * so on a full checkout it roughly doubles the total directories > watched. It only exists to > >> + * pick up externally-produced {@code .class} files (e.g. running > {@code ./gradlew -t > >> + * classes} in a second terminal); in-process compiles hot-swap > directly and never need it. > >> + * Off by default so unscoped runs need meaningfully fewer real > watch registrations. > >> + */ > >> + private boolean watchBuildOutput; > >> + > >> + @Override > >> + public void init(List<StartupCommand> ofbizCommands, String name, > String configFile) throws ContainerException { > >> + this.name = name; > >> + > >> + if > (!"true".equalsIgnoreCase(System.getProperty("ofbiz.hotreload"))) { > >> + Debug.logInfo("DevReloadContainer is disabled. Use > -Dofbiz.hotreload=true to enable.", MODULE); > >> + return; > >> + } > >> + > >> + parseHotReloadProperties(); > >> + attachHotSwapAgent(); > >> + > >> + if (!prepareClassesDir()) { > >> + return; > >> + } > >> + if (!prepareHotReloadOutputDir()) { > >> + return; > >> + } > >> + createWatchService(); > >> + registerBuildOutputWatchIfEnabled(); > >> + startDebounceExecutor(); > >> + > >> + Debug.logInfo("DevReloadContainer ready — compiled output at " > + hotReloadOutputDir.toAbsolutePath(), MODULE); > >> + } > >> + > >> + /** > >> + * Reads {@code -Dofbiz.hotreload.components} and {@code > -Dofbiz.hotreload.watchBuildOutput}, > >> + * populating {@link #allowedComponents} and {@link > #watchBuildOutput}. > >> + */ > >> + private void parseHotReloadProperties() { > >> + String componentsProperty = > System.getProperty("ofbiz.hotreload.components"); > >> + if (componentsProperty != null && > !componentsProperty.isBlank()) { > >> + allowedComponents = > Arrays.stream(componentsProperty.split(",")) > >> + .map(String::trim) > >> + .filter(s -> !s.isEmpty()) > >> + .collect(Collectors.toSet()); > >> + Debug.logInfo("Hot-reload: scoped to components " + > allowedComponents > >> + + " (set via -Dofbiz.hotreload.components)", > MODULE); > >> + } > >> + > >> + watchBuildOutput = > "true".equalsIgnoreCase(System.getProperty("ofbiz.hotreload.watchBuildOutput")); > >> + } > >> + > >> + /** > >> + * Self-attaches {@link HotSwapAgent} so Java class redefinition > is available. Failure > >> + * here is non-fatal and never aborts {@link #init}: Java hot-swap > is simply disabled > >> + * while {@code services.xml} auto-reload still works. > >> + */ > >> + private void attachHotSwapAgent() { > >> + try { > >> + instrumentation = HotSwapAgent.install(); > >> + Debug.logInfo("Hot-reload: self-attached HotSwapAgent — > Java class redefinition is available.", MODULE); > >> + if (enhancedRedefinitionRequested()) { > >> + Debug.logInfo("Hot-reload: > -XX:+AllowEnhancedClassRedefinition detected — running on a JVM " > >> + + "(e.g. JetBrains Runtime) that can also > hot-swap structural changes (added/removed " > >> + + "methods or fields, changed signatures), not > just method bodies.", MODULE); > >> + } else { > >> + Debug.logWarning("Hot-reload: structural changes > (added/removed methods or fields, changed " > >> + + "signatures) will require a restart on this > JVM. './gradlew ofbizDev' requires a " > >> + + "DCEVM-patched JVM and refuses to start > without one, so you're most likely seeing " > >> + + "this because hot-reload was activated some > other way on a stock JDK. See " > >> + + "plugins/devreload/README.md to set up > DCEVM_HOME.", MODULE); > >> + } > >> + } catch (Exception e) { > >> + Debug.logWarning("Hot-reload: could not self-attach > HotSwapAgent (" + e.getMessage() > >> + + "). Add -Djdk.attach.allowAttachSelf=true to JVM > args. " > >> + + "Java class changes will require a restart; > services.xml auto-reload still works.", MODULE); > >> + } > >> + } > >> + > >> + /** Sets {@link #classesDir}. Returns {@code false} (after > logging) if it doesn't exist yet. */ > >> + private boolean prepareClassesDir() { > >> + classesDir = Paths.get("build/classes/java/main"); > >> + if (!Files.exists(classesDir)) { > >> + Debug.logWarning("Hot-reload: classes directory not found > at " + classesDir.toAbsolutePath() > >> + + ". Run './gradlew classes' first, then > restart.", MODULE); > >> + return false; > >> + } > >> + return true; > >> + } > >> + > >> + /** > >> + * Sets {@link #hotReloadOutputDir} and clears/recreates it. > Returns {@code false} (after > >> + * logging) if the directory could not be prepared -- without a > writable output directory, > >> + * in-process compilation cannot work at all, so the whole > container is disabled up front > >> + * instead of continuing to a misleading "ready" log. > >> + */ > >> + private boolean prepareHotReloadOutputDir() { > >> + // build.gradle passes this down as > -Dofbiz.hotreload.outputDir, computed from the > >> + // same value it prepends to the classpath, so the path exists > in exactly one place > >> + // rather than being hardcoded independently here too. The > literal default below is > >> + // only a fallback for the (unsupported) case of starting this > container without > >> + // going through the ofbizDev Gradle task. > >> + hotReloadOutputDir = > Paths.get(System.getProperty("ofbiz.hotreload.outputDir", > "build/devreload/classes")); > >> + try { > >> + FileUtils.deleteDirectory(hotReloadOutputDir.toFile()); > >> + Files.createDirectories(hotReloadOutputDir); > >> + return true; > >> + } catch (IOException e) { > >> + Debug.logWarning("Hot-reload: could not prepare this > plugin's own output directory " > >> + + hotReloadOutputDir.toAbsolutePath() + ": " + > e.getMessage(), MODULE); > >> + return false; > >> + } > >> + } > >> + > >> + /** Creates {@link #watchService} on {@link #classesDir}'s > filesystem. */ > >> + private void createWatchService() throws ContainerException { > >> + try { > >> + watchService = > classesDir.getFileSystem().newWatchService(); > >> + } catch (IOException e) { > >> + throw new ContainerException("DevReloadContainer: failed > to initialise WatchService", e); > >> + } > >> + } > >> + > >> + /** > >> + * Registers {@link #classesDir} with the WatchService when {@link > #watchBuildOutput} is > >> + * on, so externally-produced {@code .class} files (e.g. {@code > ./gradlew -t classes} in > >> + * a second terminal) are picked up too. > >> + */ > >> + private void registerBuildOutputWatchIfEnabled() { > >> + if (watchBuildOutput) { > >> + try { > >> + registerAll(classesDir); > >> + } catch (IOException e) { > >> + // registerAll() already logs a warning and skips > individual directories > >> + // that fail to register; reaching here means > something more fundamental > >> + // broke walking the tree at all (e.g. can't even list > classesDir). > >> + Debug.logWarning("Hot-reload: could not fully walk " + > classesDir + ": " + e.getMessage(), MODULE); > >> + } > >> + Debug.logInfo("Hot-reload: watching compiled-output > directory " + classesDir.toAbsolutePath() > >> + + " for externally-produced .class files (set via > -Dofbiz.hotreload.watchBuildOutput=true).", > >> + MODULE); > >> + } else { > >> + Debug.logInfo("Hot-reload: not watching " + > classesDir.toAbsolutePath() + " (this tree isn't " > >> + + "narrowed by -Dofbiz.hotreload.components and > roughly doubles the total directories " > >> + + "watched). In-process edits still hot-swap > normally; running './gradlew -t classes' in a " > >> + + "second terminal will not be picked up unless > you set " > >> + + "-Dofbiz.hotreload.watchBuildOutput=true (or > -Photreload.watchBuildOutput=true with the " > >> + + "ofbizDev Gradle task).", MODULE); > >> + } > >> + } > >> + > >> + /** Starts the daemon executor backing every {@link Debouncer}. */ > >> + private void startDebounceExecutor() { > >> + debounceExecutor = > Executors.newSingleThreadScheduledExecutor(r -> { > >> + Thread t = new Thread(r, "ofbiz-hot-reload-debouncer"); > >> + t.setDaemon(true); > >> + return t; > >> + }); > >> + } > >> + > >> + /** > >> + * Picks whichever of this plugin's own compiled output ({@code > overlay}, under > >> + * {@link #hotReloadOutputDir}) or Gradle's ({@code fallback}, > under {@link #classesDir}) > >> + * is the right one to redefine from. {@code overlay} always wins > when it exists, > >> + * matching its position ahead of {@code fallback} on the runtime > classpath (see > >> + * {@code build.gradle}) — a class compiled here is always the one > a caller would load. > >> + * Returns {@code null} if neither exists. > >> + */ > >> + private Path resolveClassFile(Path overlay, Path fallback) { > >> + if (Files.exists(overlay)) { > >> + return overlay; > >> + } > >> + if (Files.exists(fallback)) { > >> + return fallback; > >> + } > >> + return null; > >> + } > >> + > >> + @Override > >> + public boolean start() throws ContainerException { > >> + if (watchService == null) { > >> + return true; // disabled > >> + } > >> + registerServicedefDirs(); > >> + registerSourceDirs(); > >> + if (watchDirsFailed > 0) { > >> + Debug.logWarning("Hot-reload: " + watchDirsFailed + " of " > + watchDirsAttempted + " directory watch " > >> + + "registrations hit file-descriptor/watch > exhaustion (see warnings above for which ones) " > >> + + "and are NOT being watched — changes there will > not hot-reload until you restart. Scope " > >> + + "hot-reload to just the components you're > working on with " > >> + + "-Dofbiz.hotreload.components=compA,compB (or > -Photreload.components=compA,compB with " > >> + + "the ofbizDev Gradle task) to fit under the OS > watch limit.", MODULE); > >> + } > >> + watchThread = new Thread(this::watchLoop, > "ofbiz-hot-reload-watcher"); > >> + watchThread.setDaemon(true); > >> + watchThread.start(); > >> + Debug.logInfo("DevReloadContainer started. Edit any Java or > services.xml file and changes go live without a restart.", MODULE); > >> + return true; > >> + } > >> + > >> + /** > >> + * Registers every directory that contains a component > service-definition XML file > >> + * (type="model") with the WatchService so that edits to those > files are detected. > >> + * Called once from {@link #start()}, before the watch thread > launches. > >> + */ > >> + private void registerServicedefDirs() { > >> + for (ComponentConfig.ServiceResourceInfo sri : > ComponentConfig.getAllServiceResourceInfos("model")) { > >> + if (allowedComponents != null && > !allowedComponents.contains(sri.getComponentConfig().getComponentName())) { > >> + continue; > >> + } > >> + try { > >> + URL url = sri.createResourceHandler().getURL(); > >> + if (!"file".equals(url.getProtocol())) { > >> + continue; // skip non-filesystem resources > (classpath jars, etc.) > >> + } > >> + Path dir = Paths.get(new > URI(url.toString())).getParent(); > >> + if (dir != null && Files.isDirectory(dir) && > servicedefDirs.add(dir)) { > >> + watchDirsAttempted++; > >> + try { > >> + dir.register(watchService, > >> + StandardWatchEventKinds.ENTRY_CREATE, > >> + StandardWatchEventKinds.ENTRY_MODIFY); > >> + Debug.logInfo("Hot-reload: watching servicedef > directory " + dir, MODULE); > >> + } catch (IOException e) { > >> + warnUnwatched(dir, e); > >> + } > >> + } > >> + } catch (GenericConfigException | URISyntaxException e) { > >> + Debug.logWarning("Hot-reload: could not register > servicedef dir for " > >> + + sri.getLocation() + ": " + e.getMessage(), > MODULE); > >> + } catch (Throwable t) { > >> + // Defensive: a single component's servicedef > registration must not be able > >> + // to abort the loop and leave every subsequent > component's servicedef > >> + // directory unwatched. > >> + Debug.logError(t, "Hot-reload: unexpected error > registering servicedef dir for " > >> + + sri.getLocation(), MODULE); > >> + } > >> + } > >> + } > >> + > >> + /** > >> + * Registers every component's {@code src/main/java} directory > with the WatchService > >> + * so that saving a {@code .java} file triggers in-process > compilation via > >> + * {@link ToolProvider#getSystemJavaCompiler()}. Falls back > gracefully when running > >> + * on a JRE (compiler unavailable) — source watching is simply > skipped. > >> + */ > >> + private void registerSourceDirs() { > >> + if (ToolProvider.getSystemJavaCompiler() == null) { > >> + Debug.logWarning("Hot-reload: javax.tools.JavaCompiler not > available (JRE, not JDK?). " > >> + + "Java source auto-compilation disabled — use > './gradlew -t classes' in a second terminal.", MODULE); > >> + return; > >> + } > >> + for (ComponentConfig cc : ComponentConfig.getAllComponents()) { > >> + if (cc.rootLocation() == null) { > >> + continue; > >> + } > >> + if (allowedComponents != null && > !allowedComponents.contains(cc.getComponentName())) { > >> + continue; > >> + } > >> + Path srcDir = cc.rootLocation().resolve("src/main/java"); > >> + if (Files.isDirectory(srcDir) && > sourceRootDirs.add(srcDir)) { > >> + try { > >> + registerAll(srcDir); > >> + Debug.logInfo("Hot-reload: watching source > directory " + srcDir, MODULE); > >> + } catch (IOException e) { > >> + // registerAll() already logs a warning and skips > individual directories > >> + // that fail to register; reaching here means > something more fundamental > >> + // broke walking the tree at all (e.g. can't list > srcDir). > >> + Debug.logWarning("Hot-reload: could not walk > source dir " + srcDir + ": " + e.getMessage(), MODULE); > >> + } > >> + } > >> + } > >> + if (!sourceRootDirs.isEmpty()) { > >> + Debug.logInfo("Hot-reload: Java source auto-compilation > active — save a .java file and it reloads automatically.", MODULE); > >> + } > >> + } > >> + > >> + @Override > >> + public void stop() throws ContainerException { > >> + if (debounceExecutor != null) { > >> + debounceExecutor.shutdownNow(); > >> + } > >> + if (watchService != null) { > >> + try { > >> + watchService.close(); > >> + } catch (IOException e) { > >> + Debug.logError(e, "DevReloadContainer: error closing > WatchService", MODULE); > >> + } > >> + } > >> + if (watchThread != null) { > >> + watchThread.interrupt(); > >> + } > >> + } > >> + > >> + @Override > >> + public String getName() { > >> + return name; > >> + } > >> + > >> + // > ------------------------------------------------------------------------- > >> + // Watch loop > >> + // > ------------------------------------------------------------------------- > >> + > >> + private void watchLoop() { > >> + while (!Thread.currentThread().isInterrupted()) { > >> + WatchKey key; > >> + try { > >> + key = watchService.take(); > >> + } catch (InterruptedException e) { > >> + Thread.currentThread().interrupt(); > >> + break; > >> + } catch (ClosedWatchServiceException e) { > >> + break; > >> + } > >> + > >> + Path dir = (Path) key.watchable(); > >> + for (WatchEvent<?> event : key.pollEvents()) { > >> + WatchEvent.Kind<?> kind = event.kind(); > >> + if (kind == StandardWatchEventKinds.OVERFLOW) { > >> + continue; > >> + } > >> + > >> + @SuppressWarnings("unchecked") > >> + Path changed = dir.resolve(((WatchEvent<Path>) > event).context()); > >> + > >> + if (kind == StandardWatchEventKinds.ENTRY_CREATE && > Files.isDirectory(changed)) { > >> + // New package directory created during > compilation — register it. > >> + try { > >> + registerAll(changed); > >> + } catch (IOException e) { > >> + Debug.logError(e, "DevReloadContainer: failed > to register new directory: " + changed, MODULE); > >> + } > >> + } else if ((kind == > StandardWatchEventKinds.ENTRY_CREATE || kind == > StandardWatchEventKinds.ENTRY_MODIFY) > >> + && changed.toString().endsWith(".class")) { > >> + // Only react to written/updated class files. > Ignore ENTRY_DELETE so > >> + // that removing a source file (and its .class > output) does not cause > >> + // a redefinition attempt against a now-missing > file. > >> + reloadClassFile(classesDir, changed); > >> + } else if ((kind == > StandardWatchEventKinds.ENTRY_CREATE || kind == > StandardWatchEventKinds.ENTRY_MODIFY) > >> + && changed.toString().endsWith(".xml") > >> + && > servicedefDirs.stream().anyMatch(dir::startsWith)) { > >> + xmlReloadDebouncer.add(changed); > >> + } else if ((kind == > StandardWatchEventKinds.ENTRY_CREATE || kind == > StandardWatchEventKinds.ENTRY_MODIFY) > >> + && changed.toString().endsWith(".java") > >> + && > sourceRootDirs.stream().anyMatch(dir::startsWith)) { > >> + compileDebouncer.add(changed); > >> + } > >> + } > >> + if (!key.reset()) { > >> + Debug.logWarning("Hot-reload: watch key became invalid > (directory deleted?): " > >> + + key.watchable() + ". WatchService will no > longer detect changes in that directory.", MODULE); > >> + } > >> + } > >> + } > >> + > >> + // > ------------------------------------------------------------------------- > >> + // Debounced batching > >> + // > ------------------------------------------------------------------------- > >> + > >> + /** > >> + * Coalesces rapid-fire change notifications into one action, so a > single compile run > >> + * that touches many files (e.g. one with inner/anonymous classes, > or a Gradle build > >> + * writing several {@code .class} files at once) is handled as a > single batch instead > >> + * of one action per file. Shared by all three change pipelines > (class reload, > >> + * {@code services.xml} reload, Java compile) instead of each > hand-rolling its own > >> + * pending-set/cancel/reschedule bookkeeping. > >> + */ > >> + private final class Debouncer<T> { > >> + private final Set<T> pending = new HashSet<>(); > >> + private final Consumer<Set<T>> action; > >> + private ScheduledFuture<?> scheduled; > >> + > >> + Debouncer(Consumer<Set<T>> action) { > >> + this.action = action; > >> + } > >> + > >> + synchronized void add(T item) { > >> + pending.add(item); > >> + if (scheduled != null) { > >> + scheduled.cancel(false); > >> + } > >> + try { > >> + // Wait 300 ms after the last change so a burst of > related changes (e.g. a > >> + // single Gradle compile run writing multiple .class > files) is handled as > >> + // one batch instead of one action per file. > >> + scheduled = debounceExecutor.schedule(this::fire, 300, > TimeUnit.MILLISECONDS); > >> + } catch (RejectedExecutionException e) { > >> + // Container is shutting down; pending changes will > not be applied. > >> + } > >> + } > >> + > >> + private synchronized void fire() { > >> + if (pending.isEmpty()) { > >> + return; > >> + } > >> + Set<T> batch = new HashSet<>(pending); > >> + pending.clear(); > >> + action.accept(batch); > >> + } > >> + } > >> + > >> + /** Resolves {@code changed} to a class name relative to {@code > baseDir} and, if valid, queues it for reload. */ > >> + private void reloadClassFile(Path baseDir, Path changed) { > >> + String className = toClassName(baseDir, changed); > >> + if (className != null) { > >> + classReloadDebouncer.add(className); > >> + } > >> + } > >> + > >> + private void applyReload(Set<String> batch) { > >> + Debug.logInfo("Hot-reload: detected changes in " + batch, > MODULE); > >> + > >> + if (instrumentation == null) { > >> + Debug.logWarning("Hot-reload: HotSwapAgent not attached — > " + batch > >> + + " compiled but not applied to the running JVM. > Restart to pick it up.", MODULE); > >> + return; > >> + } > >> + > >> + List<ClassDefinition> defs = new ArrayList<>(); > >> + for (String className : batch) { > >> + Path relative = Paths.get(className.replace('.', '/') + > ".class"); > >> + Path overlayFile = hotReloadOutputDir.resolve(relative); > >> + Path gradleFile = classesDir.resolve(relative); > >> + Path classFile = resolveClassFile(overlayFile, gradleFile); > >> + if (classFile == null) { > >> + Debug.logWarning("Hot-reload: detected a change for " > + className > >> + + " but could not find its compiled output in > either " > >> + + hotReloadOutputDir.toAbsolutePath() + " or " > + classesDir.toAbsolutePath(), MODULE); > >> + continue; > >> + } > >> + try { > >> + Class<?> loaded = findLoadedClass(className); > >> + if (loaded == null) { > >> + // Never loaded yet in this JVM — nothing to > redefine. It will simply > >> + // load fresh, with the new bytecode, the first > time something > >> + // references it, from whichever directory > resolveClassFile() would > >> + // pick (overlay first on the classpath too, see > build.gradle). > >> + continue; > >> + } > >> + defs.add(new ClassDefinition(loaded, > Files.readAllBytes(classFile))); > >> + } catch (IOException e) { > >> + Debug.logError(e, "Hot-reload: failed to read class > file for " + className, MODULE); > >> + } > >> + } > >> + > >> + if (defs.isEmpty()) { > >> + Debug.logInfo("Hot-reload: nothing already loaded to > redefine for " + batch, MODULE); > >> + return; > >> + } > >> + > >> + try { > >> + instrumentation.redefineClasses(defs.toArray(new > ClassDefinition[0])); > >> + // Clear service definition cache so newly added service > methods are discovered. > >> + // We deliberately do NOT clear webapp.Controller caches > here — controller.xml > >> + // has not changed, only .class files have, and clearing > those caches triggers > >> + // Groovy re-compilation of screen expressions which can > fail unexpectedly. > >> + UtilCache.clearCache(SERVICE_MODEL_CACHE_NAME); > >> + Debug.logInfo("Hot-reload complete for: " + batch, MODULE); > >> + } catch (UnsupportedOperationException e) { > >> + // ./gradlew ofbizDev only ever runs on a DCEVM-patched > JVM (see build.gradle), > >> + // which already lifts the plain-JVM restriction to method > bodies only, so > >> + // add/remove method-or-field and signature changes > normally succeed here. This > >> + // still fires for the narrower set of changes DCEVM > itself can't apply either > >> + // (e.g. a changed class hierarchy) -- the same remaining > limit an IDE debugger's > >> + // HotSwap has even on a capable JVM. > >> + Debug.logWarning("Hot-reload: " + batch + " contains a > structural change (added/removed " > >> + + "method or field, changed signature, changed > hierarchy) that the JVM cannot " > >> + + "hot-swap. Restart OFBiz to pick it up. (" + > e.getMessage() + ")", MODULE); > >> + } catch (Throwable e) { > >> + Debug.logError(e, "Hot-reload failed for " + batch, > MODULE); > >> + } > >> + } > >> + > >> + /** > >> + * Best-effort detection of whether this JVM was launched with > >> + * {@code -XX:+AllowEnhancedClassRedefinition} (e.g. a JetBrains > Runtime), which is > >> + * what allows {@link Instrumentation#redefineClasses} to also > apply structural > >> + * changes instead of just method bodies. Purely informational — > the actual > >> + * capability is exercised (and, if absent, reported) when a > redefinition is > >> + * attempted in {@link #applyReload}. > >> + */ > >> + private static boolean enhancedRedefinitionRequested() { > >> + return > ManagementFactory.getRuntimeMXBean().getInputArguments().stream() > >> + .anyMatch(arg -> > arg.contains("AllowEnhancedClassRedefinition")); > >> + } > >> + > >> + /** Searches classes already loaded in the JVM for one matching > {@code className}. */ > >> + private Class<?> findLoadedClass(String className) { > >> + for (Class<?> c : instrumentation.getAllLoadedClasses()) { > >> + if (c.getName().equals(className)) { > >> + return c; > >> + } > >> + } > >> + return null; > >> + } > >> + > >> + private void applyServiceXmlReload(Set<Path> batch) { > >> + Debug.logInfo("Hot-reload: service XML changed " + batch + " — > clearing service model cache", MODULE); > >> + try { > >> + UtilCache.clearCache(SERVICE_MODEL_CACHE_NAME); > >> + Debug.logInfo("Hot-reload: service model cache cleared; > definitions will be re-read on next service call", MODULE); > >> + } catch (Throwable e) { > >> + Debug.logError(e, "Hot-reload: failed to clear service > model cache", MODULE); > >> + } > >> + } > >> + > >> + private void applyCompile(Set<Path> batch) { > >> + Debug.logInfo("Hot-reload: compiling " + batch, MODULE); > >> + try { > >> + JavaCompiler compiler = > ToolProvider.getSystemJavaCompiler(); > >> + if (compiler == null) { > >> + return; > >> + } > >> + try (StandardJavaFileManager fm = > compiler.getStandardFileManager(null, null, null)) { > >> + fm.setLocation(StandardLocation.CLASS_OUTPUT, > >> + List.of(hotReloadOutputDir.toAbsolutePath().toFile())); > >> + // Reuse the running JVM's classpath — it already > contains all OFBiz jars. > >> + List<String> options = Arrays.asList("-cp", > System.getProperty("java.class.path"), "-proc:none"); > >> + var units = fm.getJavaFileObjectsFromPaths(batch); > >> + boolean ok = compiler.getTask(null, fm, null, options, > null, units).call(); > >> + if (ok) { > >> + Debug.logInfo("Hot-reload: compilation > successful", MODULE); > >> + > >> + // Collect all .class files produced by this > compilation round. > >> + // Each source file can produce multiple .class > files when it contains > >> + // inner or anonymous classes (e.g. Foo$Bar.class, > Foo$1.class). > >> + // All of them must be redefined too — otherwise > the inner class still > >> + // resolves through its stale, previously-loaded > bytecode. > >> + for (Path src : batch) { > >> + Path cf = sourceToClassFile(src); // relative > path for the outer class > >> + if (cf == null) { > >> + continue; > >> + } > >> + String outerName = > cf.getFileName().toString().replace(".class", ""); > >> + Path absOutputDir = > cf.toAbsolutePath().getParent(); > >> + try (var dirStream = Files.list(absOutputDir)) > { > >> + dirStream.filter(absFile -> { > >> + String fn = > absFile.getFileName().toString(); > >> + // Match Foo.class and Foo$Inner.class > / Foo$1.class > >> + return fn.endsWith(".class") > >> + && (fn.equals(outerName + > ".class") > >> + || > fn.startsWith(outerName + "$")); > >> + }).forEach(absFile -> { > >> + // Convert absolute output path back > to a relative path that > >> + // is rooted at CWD (same type as > hotReloadOutputDir) so that > >> + // toClassName(hotReloadOutputDir, > relPath) — which calls > >> + // relativize — does not throw > IllegalArgumentException. > >> + Path rel = hotReloadOutputDir.resolve( > >> + hotReloadOutputDir.toAbsolutePath().relativize(absFile)); > >> + reloadClassFile(hotReloadOutputDir, rel); > >> + }); > >> + } catch (IOException e) { > >> + // Output dir unreadable; fall back to the > outer class only. > >> + reloadClassFile(hotReloadOutputDir, cf); > >> + } > >> + } > >> + > >> + // Re-register class directories so external > compilations (./gradlew classes > >> + // run by a developer in a separate terminal) > still reach the class watcher. > >> + // Only relevant if that watch is enabled in the > first place (watchBuildOutput); > >> + // otherwise there is nothing registered under > classesDir to refresh. > >> + // Catch Exception (not just IOException) because > ClosedWatchServiceException > >> + // extends IllegalStateException, which is a > RuntimeException — it can be > >> + // thrown here if OFBiz is shutting down while a > compile finishes. > >> + if (watchBuildOutput) { > >> + try { > >> + registerAll(classesDir); > >> + } catch (Exception e) { > >> + Debug.logWarning("Hot-reload: could not > re-register class dirs: " + e.getMessage(), MODULE); > >> + } > >> + } > >> + } else { > >> + Debug.logWarning("Hot-reload: compilation failed — > fix the error and save again", MODULE); > >> + } > >> + } > >> + } catch (Throwable e) { > >> + Debug.logError(e, "Hot-reload: compilation error", MODULE); > >> + } > >> + } > >> + > >> + /** > >> + * Maps a {@code .java} source file to the corresponding {@code > .class} output file > >> + * under {@link #hotReloadOutputDir}. Returns {@code null} if the > source file is not > >> + * under any registered source root. > >> + */ > >> + private Path sourceToClassFile(Path sourceFile) { > >> + for (Path srcRoot : sourceRootDirs) { > >> + if (sourceFile.startsWith(srcRoot)) { > >> + Path relative = srcRoot.relativize(sourceFile); > >> + String name = relative.toString(); > >> + if (name.endsWith(".java")) { > >> + String classRelative = name.substring(0, > name.length() - ".java".length()) + ".class"; > >> + return hotReloadOutputDir.resolve(classRelative); > >> + } > >> + } > >> + } > >> + return null; > >> + } > >> + > >> + // > ------------------------------------------------------------------------- > >> + // Helpers > >> + // > ------------------------------------------------------------------------- > >> + > >> + /** > >> + * Recursively registers every directory under {@code start} with > the WatchService. > >> + * A directory whose registration fails (e.g. watch/descriptor > exhaustion) is logged > >> + * and left unwatched via {@link #warnUnwatched} instead of > aborting the whole walk, > >> + * so one overloaded directory never leaves the rest of the tree > unwatched. > >> + */ > >> + private void registerAll(Path start) throws IOException { > >> + Files.walkFileTree(start, new SimpleFileVisitor<Path>() { > >> + @Override > >> + public FileVisitResult preVisitDirectory(Path dir, > BasicFileAttributes attrs) { > >> + watchDirsAttempted++; > >> + try { > >> + dir.register(watchService, > >> + StandardWatchEventKinds.ENTRY_CREATE, > >> + StandardWatchEventKinds.ENTRY_MODIFY); > >> + } catch (IOException e) { > >> + warnUnwatched(dir, e); > >> + } catch (Throwable t) { > >> + // register() itself should only throw > IOException, but nothing here is > >> + // worth crashing the whole startup over. > >> + Debug.logError(t, "Hot-reload: unexpected error > registering watch for " + dir > >> + + " -- this directory will not be > watched.", MODULE); > >> + } > >> + return FileVisitResult.CONTINUE; > >> + } > >> + }); > >> + } > >> + > >> + /** > >> + * Records that {@code dir} could not get a WatchService > registration (most commonly > >> + * the OS's per-process watch ceiling, e.g. macOS's > kqueue-per-directory cost) and > >> + * logs why. The directory is simply left unwatched: changes there > require a restart > >> + * (or {@code -Dofbiz.hotreload.components}/{@code > -Photreload.components} to narrow > >> + * the watched set below the ceiling) rather than falling back to > some slower > >> + * alternate mechanism. > >> + */ > >> + private void warnUnwatched(Path dir, IOException cause) { > >> + watchDirsFailed++; > >> + Debug.logWarning("Hot-reload: could not watch " + dir + " (" + > cause.getMessage() + ") -- changes " > >> + + "there will not be picked up until OFBiz is > restarted. Narrow the watched set with " > >> + + "-Dofbiz.hotreload.components=compA,compB (or > -Photreload.components=compA,compB with the " > >> + + "ofbizDev Gradle task) to fit under the OS watch > limit.", MODULE); > >> + } > >> + > >> + /** > >> + * Converts a {@code .class} file path relative to {@code baseDir} > into a > >> + * binary class name. > >> + * > >> + * <p>Example: {@code com/example/Foo.class} → {@code > com.example.Foo} > >> + */ > >> + private static String toClassName(Path baseDir, Path classFile) { > >> + Path relative = baseDir.relativize(classFile); > >> + String s = relative.toString(); > >> + if (!s.endsWith(".class")) { > >> + return null; > >> + } > >> + // Normalise path separator to '.' and strip the '.class' > suffix > >> + return s.substring(0, s.length() - ".class".length()) > >> + .replace(classFile.getFileSystem().getSeparator(), "."); > >> + } > >> +} > >> diff --git > a/devreload/src/main/java/org/apache/ofbiz/devreload/HotSwapAgent.java > >> b/devreload/src/main/java/org/apache/ofbiz/devreload/HotSwapAgent.java > >> new file mode 100644 > >> index 000000000..f3542a5bf > >> --- /dev/null > >> +++ > b/devreload/src/main/java/org/apache/ofbiz/devreload/HotSwapAgent.java > >> @@ -0,0 +1,109 @@ > >> > +/******************************************************************************* > >> + * Licensed to the Apache Software Foundation (ASF) under one > >> + * or more contributor license agreements. See the NOTICE file > >> + * distributed with this work for additional information > >> + * regarding copyright ownership. The ASF licenses this file > >> + * to you under the Apache License, Version 2.0 (the > >> + * "License"); you may not use this file except in compliance > >> + * with the License. You may obtain a copy of the License at > >> + * > >> + *http://www.apache.org/licenses/LICENSE-2.0 > >> + * > >> + * Unless required by applicable law or agreed to in writing, > >> + * software distributed under the License is distributed on an > >> + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY > >> + * KIND, either express or implied. See the License for the > >> + * specific language governing permissions and limitations > >> + * under the License. > >> + > *******************************************************************************/ > >> +package org.apache.ofbiz.devreload; > >> + > >> +import java.io.IOException; > >> +import java.io.InputStream; > >> +import java.io.OutputStream; > >> +import java.lang.instrument.Instrumentation; > >> +import java.nio.file.Files; > >> +import java.nio.file.Path; > >> +import java.util.jar.Attributes; > >> +import java.util.jar.JarOutputStream; > >> +import java.util.jar.Manifest; > >> +import java.util.zip.ZipEntry; > >> + > >> +import com.sun.tools.attach.VirtualMachine; > >> + > >> +/** > >> + * Self-attaching Java agent that gives {@link DevReloadContainer} > access to > >> + * {@link Instrumentation#redefineClasses}, the same JVM mechanism an > IDE debugger uses > >> + * for HotSwap — it replaces the bytecode of an already-loaded {@link > Class} object in > >> + * place, so every existing reference to it (including cached {@code > Class} objects in > >> + * framework classes like {@code JavaEventHandler}) picks up the new > method bodies on the > >> + * very next call. > >> + * > >> + * <p>The agent jar is built on the fly from this class's own compiled > bytecode and > >> + * attached to the current process via the JDK Attach API — no {@code > -javaagent} JVM > >> + * flag, and no framework code changes. This class and {@link > DevReloadContainer} are the > >> + * only two moving parts. > >> + * > >> + * <p>Requires the JVM flag {@code -Djdk.attach.allowAttachSelf=true} > (a JDK 9+ safeguard > >> + * against a process attaching to itself). The {@code ofbizDev} Gradle > task provided by > >> + * this plugin sets it automatically. > >> + */ > >> +public final class HotSwapAgent { > >> + > >> + private static volatile Instrumentation instrumentation; > >> + > >> + private HotSwapAgent() { } > >> + > >> + /** Invoked by the JVM once {@link VirtualMachine#loadAgent} loads > this class as an agent. */ > >> + public static void agentmain(String agentArgs, Instrumentation > inst) { > >> + instrumentation = inst; > >> + } > >> + > >> + /** > >> + * Builds a minimal agent jar wrapping this class and > self-attaches it to the current > >> + * JVM, returning the resulting {@link Instrumentation}. Safe to > call more than once; > >> + * later calls return the instance obtained by the first > successful attach. > >> + */ > >> + static synchronized Instrumentation install() throws Exception { > >> + if (instrumentation != null) { > >> + return instrumentation; > >> + } > >> + Path agentJar = buildAgentJar(); > >> + try { > >> + String pid = String.valueOf(ProcessHandle.current().pid()); > >> + VirtualMachine vm = VirtualMachine.attach(pid); > >> + try { > >> + vm.loadAgent(agentJar.toAbsolutePath().toString()); > >> + } finally { > >> + vm.detach(); > >> + } > >> + } finally { > >> + Files.deleteIfExists(agentJar); > >> + } > >> + return instrumentation; > >> + } > >> + > >> + private static Path buildAgentJar() throws IOException { > >> + String resource = HotSwapAgent.class.getName().replace('.', > '/') + ".class"; > >> + Path jar = Files.createTempFile("devreload-hotswap-agent", > ".jar"); > >> + > >> + Manifest manifest = new Manifest(); > >> + Attributes attrs = manifest.getMainAttributes(); > >> + attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0"); > >> + attrs.put(new Attributes.Name("Agent-Class"), > HotSwapAgent.class.getName()); > >> + attrs.put(new Attributes.Name("Can-Redefine-Classes"), "true"); > >> + attrs.put(new Attributes.Name("Can-Retransform-Classes"), > "true"); > >> + > >> + try (InputStream in = > HotSwapAgent.class.getClassLoader().getResourceAsStream(resource); > >> + OutputStream fos = Files.newOutputStream(jar); > >> + JarOutputStream jos = new JarOutputStream(fos, > manifest)) { > >> + if (in == null) { > >> + throw new IOException("Could not locate compiled class > on classpath: " + resource); > >> + } > >> + jos.putNextEntry(new ZipEntry(resource)); > >> + in.transferTo(jos); > >> + jos.closeEntry(); > >> + } > >> + return jar; > >> + } > >> +} > >> > >
