feat(bulk-model-sync-gradle): add continueOnError option

With the new option, the sync can ignore errors encountered during
syncing instead of immediately terminating. This is some sort of
graceful degradation at the cost of potentially resulting in an
inconsistent sync.

continueOnError will be implemented for local targets later on. To
inform users about this, a warning message is printed if continueOnError
is used with a local target.

Author: languitar

bulk-model-sync-gradle/src/main/kotlin/org/modelix/model/sync/bulk/gradle/ModelSyncGradlePlugin.kt

@@ -177,6 +177,7 @@ class ModelSyncGradlePlugin : Plugin<Project> {
             it.branchName.set(serverTarget.branchName)
             it.includedModules.set(syncDirection.includedModules)
             it.includedModulePrefixes.set(syncDirection.includedModulePrefixes)
+            it.continueOnError.set(syncDirection.continueOnError)
         }
 
         project.tasks.register("runSync${syncDirection.name.replaceFirstChar { it.uppercaseChar() }}") {
@@ -191,6 +192,10 @@ class ModelSyncGradlePlugin : Plugin<Project> {
         previousTask: TaskProvider<*>,
         jsonDir: File,
     ) {
+        if (syncDirection.continueOnError) {
+            println("Continue on error is currently not supported for local targets")
+        }
+
         val localTarget = syncDirection.target as LocalTarget
 
         val antScript = jsonDir.resolve("build.xml")

bulk-model-sync-gradle/src/main/kotlin/org/modelix/model/sync/bulk/gradle/config/ModelSyncGradleSettings.kt

@@ -43,6 +43,7 @@ data class SyncDirection(
     internal val registeredLanguages: Set<ILanguage> = mutableSetOf(),
     internal val includedModulePrefixes: Set<String> = mutableSetOf(),
     internal var mpsDebugEnabled: Boolean = false,
+    internal var continueOnError: Boolean = false,
 ) {
     fun fromModelServer(action: Action<ServerSource>) {
         val endpoint = ServerSource()
@@ -79,6 +80,10 @@ data class SyncDirection(
     fun registerLanguage(language: ILanguage) {
         (registeredLanguages as MutableSet).add(language)
     }
+
+    fun enableContinueOnError(state: Boolean) {
+        continueOnError = state
+    }
 }
 
 interface SyncEndpoint {

bulk-model-sync-gradle/src/main/kotlin/org/modelix/model/sync/bulk/gradle/tasks/ImportIntoModelServer.kt

@@ -62,6 +62,9 @@ abstract class ImportIntoModelServer @Inject constructor(of: ObjectFactory) : De
     @Input
     val includedModulePrefixes: SetProperty<String> = of.setProperty(String::class.java)
 
+    @Input
+    val continueOnError: Property<Boolean> = of.property(Boolean::class.java)
+
     @TaskAction
     fun import() {
         registeredLanguages.get().forEach {
@@ -83,7 +86,7 @@ abstract class ImportIntoModelServer @Inject constructor(of: ObjectFactory) : De
             client.runWrite(branchRef) { rootNode ->
                 logger.info("Got root node: {}", rootNode)
                 logger.info("Importing...")
-                ModelImporter(rootNode).importFilesAsRootChildren(files)
+                ModelImporter(rootNode, continueOnError.get()).importFilesAsRootChildren(files)
                 logger.info("Import finished")
             }
         }

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/ModelImporter.kt

@@ -38,7 +38,7 @@ import kotlin.jvm.JvmName
  *
  * @param root the root node to be updated
  */
-class ModelImporter(private val root: INode) {
+class ModelImporter(private val root: INode, private val continueOnError: Boolean) {
 
     private val originalIdToExisting: MutableMap<String, INode> = mutableMapOf()
     private val postponedReferences = ArrayList<() -> Unit>()
@@ -47,6 +47,22 @@ class ModelImporter(private val root: INode) {
     private var currentNodeProgress = 0
     private val logger = KotlinLogging.logger {}
 
+    // For MPS / Java compatibility, where a default value does not work. Can be dropped once the MPS solution is
+    // updated to the constructor with two arguments.
+    constructor(root: INode) : this(root, false)
+
+    private fun doAndPotentiallyContinueOnErrors(block: () -> Unit) {
+        try {
+            block()
+        } catch (e: Exception) {
+            if (continueOnError) {
+                logger.error(e) { "Ignoring this error and continuing as requested" }
+            } else {
+                throw e
+            }
+        }
+    }
+
     /**
      * Incrementally updates this importers root based on the provided [ModelData] specification.
      *
@@ -68,10 +84,18 @@ class ModelImporter(private val root: INode) {
         syncNode(root, data.root)
 
         logger.info { "Synchronizing references..." }
-        postponedReferences.forEach { it.invoke() }
+        postponedReferences.forEach {
+            doAndPotentiallyContinueOnErrors {
+                it.invoke()
+            }
+        }
 
         logger.info { "Removing extra nodes..." }
-        nodesToRemove.forEach { it.remove() }
+        nodesToRemove.forEach {
+            doAndPotentiallyContinueOnErrors {
+                it.remove()
+            }
+        }
 
         logger.info { "Synchronization finished." }
     }
@@ -83,10 +107,12 @@ class ModelImporter(private val root: INode) {
         currentNodeProgress += 1
         // print instead of log, so that the progress line can be overwritten by the carriage return
         print("\r($currentNodeProgress / $numExpectedNodes) Synchronizing nodes...                    ")
-        syncProperties(node, data)
-        syncChildren(node, data)
-        INodeResolutionScope.runWithAdditionalScope(node.getArea()) {
-            syncReferences(node, data)
+        doAndPotentiallyContinueOnErrors {
+            syncProperties(node, data)
+            syncChildren(node, data)
+            INodeResolutionScope.runWithAdditionalScope(node.getArea()) {
+                syncReferences(node, data)
+            }
         }
     }
 

docs/global/modules/core/pages/reference/component-bulk-model-sync-gradle.adoc

@@ -74,6 +74,10 @@ This means that only a minimal amount of write operations is used to update the
 |`includeModulesByPrefix`
 |String
 |Includes all modules, whose fully qualified name starts with the given prefix, in the synchronisation process.
+
+|`enableContinueOnError`
+|Boolean
+|If the sync encounters an error, simply log it and continue instead of terminating. This most likely results in an incomplete sync result. Defaults to `false`.
 |===
 
 === LocalSource/-Target configuration