From faf68e4a685f3cad7766af2ca116667d9e339c42 Mon Sep 17 00:00:00 2001
From: Tom Bishop <thomasbishop@wenlin.com>
Date: Wed, 9 Oct 2024 11:10:34 -0400
Subject: [PATCH] CLDR-17953 Improve UI and implementation for VXML generation
 (#4056)

---
 .../cldr-apps/js/src/esm/cldrGenerateVxml.mjs |  31 +-
 tools/cldr-apps/js/src/views/GenerateVxml.vue |  88 ++++-
 .../unicode/cldr/web/OutputFileManager.java   | 174 ++++------
 .../org/unicode/cldr/web/VxmlGenerator.java   |  29 +-
 .../java/org/unicode/cldr/web/VxmlQueue.java  | 317 ++++++++++--------
 .../unicode/cldr/web/api/GenerateVxml.java    |  52 ++-
 6 files changed, 382 insertions(+), 309 deletions(-)

diff --git a/tools/cldr-apps/js/src/esm/cldrGenerateVxml.mjs b/tools/cldr-apps/js/src/esm/cldrGenerateVxml.mjs
index 24f20c3b37a..b6b9bc4af9e 100644
--- a/tools/cldr-apps/js/src/esm/cldrGenerateVxml.mjs
+++ b/tools/cldr-apps/js/src/esm/cldrGenerateVxml.mjs
@@ -8,15 +8,15 @@ import * as cldrStatus from "./cldrStatus.mjs";
 
 const SECONDS_IN_MS = 1000;
 
-const NORMAL_RETRY = 10 * SECONDS_IN_MS; // "Normal" retry: starting or about to start
+const REQUEST_TIMER = 5 * SECONDS_IN_MS; // Fetch status this often
 
 const VXML_URL = "api/vxml";
 
 // These must match the back end; used in requests
-class LoadingPolicy {
+class RequestType {
   static START = "START"; // start generating vxml
   static CONTINUE = "CONTINUE"; // continue generating vxml
-  static STOP = "STOP"; // stop (cancel) generating vxml
+  static CANCEL = "CANCEL"; // cancel (stop) generating vxml
 }
 
 // These must match the back end; used in responses
@@ -24,8 +24,8 @@ class Status {
   static INIT = "INIT"; // before making a request (back end does not have INIT)
   static WAITING = "WAITING"; // waiting on other users/tasks
   static PROCESSING = "PROCESSING"; // in progress
-  static READY = "READY"; // finished successfully
-  static STOPPED = "STOPPED"; // due to error or cancellation (LoadingPolicy.STOP)
+  static SUCCEEDED = "SUCCEEDED"; // finished successfully
+  static STOPPED = "STOPPED"; // due to error, verification failure, or cancellation
 }
 
 let canGenerate = false;
@@ -45,23 +45,23 @@ function viewMounted(setData) {
 function start() {
   // Disable announcements during VXML generation to reduce risk of interference
   cldrAnnounce.enableAnnouncements(false);
-  requestVxml(LoadingPolicy.START);
+  requestVxml(RequestType.START);
 }
 
 function fetchStatus() {
   if (!canGenerate || "generate_vxml" !== cldrStatus.getCurrentSpecial()) {
     canGenerate = false;
   } else if (canGenerate) {
-    requestVxml(LoadingPolicy.CONTINUE);
+    requestVxml(RequestType.CONTINUE);
   }
 }
 
-function stop() {
-  requestVxml(LoadingPolicy.STOP);
+function cancel() {
+  requestVxml(RequestType.CANCEL);
 }
 
-function requestVxml(loadingPolicy) {
-  const args = { loadingPolicy: loadingPolicy };
+function requestVxml(requestType) {
+  const args = { requestType: requestType };
   const init = cldrAjax.makePostData(args);
   cldrAjax
     .doFetch(VXML_URL, init)
@@ -79,10 +79,13 @@ function setVxmlData(data) {
   }
   callbackToSetData(data);
   if (data.status === Status.WAITING || data.status === Status.PROCESSING) {
-    window.setTimeout(fetchStatus.bind(this), NORMAL_RETRY);
-  } else if (data.status === Status.READY || data.status === Status.STOPPED) {
+    window.setTimeout(fetchStatus.bind(this), REQUEST_TIMER);
+  } else if (
+    data.status === Status.SUCCEEDED ||
+    data.status === Status.STOPPED
+  ) {
     cldrAnnounce.enableAnnouncements(true); // restore
   }
 }
 
-export { Status, canGenerateVxml, start, stop, viewMounted };
+export { Status, cancel, canGenerateVxml, start, viewMounted };
diff --git a/tools/cldr-apps/js/src/views/GenerateVxml.vue b/tools/cldr-apps/js/src/views/GenerateVxml.vue
index 9f0c060e4e0..4d40e89b34f 100644
--- a/tools/cldr-apps/js/src/views/GenerateVxml.vue
+++ b/tools/cldr-apps/js/src/views/GenerateVxml.vue
@@ -1,5 +1,5 @@
 <script setup>
-import { onMounted, ref } from "vue";
+import { onMounted, ref, reactive } from "vue";
 
 import * as cldrGenerateVxml from "../esm/cldrGenerateVxml.mjs";
 
@@ -7,9 +7,15 @@ const STATUS = cldrGenerateVxml.Status;
 
 let hasPermission = ref(false);
 let message = ref("");
-let output = ref("");
+let directory = ref("");
+let localeId = ref("");
+let localesDone = ref(0);
+let localesTotal = ref(0);
 let percent = ref(0);
 let status = ref(STATUS.INIT);
+let verificationStatus = ref("");
+let verificationFailures = null; /* array of strings */
+let verificationWarnings = null; /* array of strings */
 
 function mounted() {
   cldrGenerateVxml.viewMounted(setData);
@@ -20,17 +26,25 @@ onMounted(mounted);
 
 function start() {
   if (hasPermission) {
-    cldrGenerateVxml.start();
+    message = ref("");
+    directory = ref("");
+    localeId = ref("");
+    localesDone = ref(0);
+    localesTotal = ref(0);
+    percent = ref(0);
     status.value = STATUS.WAITING;
+    verificationStatus = ref("");
+    verificationFailures = verificationWarnings = null;
+    cldrGenerateVxml.start();
   }
 }
 
-function stop() {
-  cldrGenerateVxml.stop();
+function cancel() {
+  cldrGenerateVxml.cancel();
   status.value = STATUS.STOPPED;
 }
 
-function canStop() {
+function canCancel() {
   return status.value === STATUS.WAITING || status.value === STATUS.PROCESSING;
 }
 
@@ -38,7 +52,30 @@ function setData(data) {
   message.value = data.message;
   percent.value = data.percent;
   status.value = data.status;
-  output.value = data.output;
+  directory.value = data.directory;
+  localeId.value = data.localeId;
+  localesDone.value = data.localesDone;
+  localesTotal.value = data.localesTotal;
+  verificationStatus.value = data.verificationStatus;
+  verificationFailures = reactive(data.verificationFailures); // array
+  verificationWarnings = reactive(data.verificationWarnings); // array
+}
+
+function copyDirectory() {
+  navigator.clipboard.writeText(directory.value);
+}
+
+function progressBarStatus() {
+  // Reference: https://ant.design/components/progress#api
+  if (status.value === STATUS.STOPPED) {
+    return "exception";
+  } else if (status.value === STATUS.SUCCEEDED) {
+    return "success";
+  } else if (percent.value > 0 && percent.value < 100) {
+    return "active";
+  } else {
+    return "normal";
+  }
 }
 
 defineExpose({
@@ -49,18 +86,34 @@ defineExpose({
 <template>
   <div v-if="!hasPermission">Please log in as Admin to use this feature.</div>
   <div v-else>
-    <p v-if="status != STATUS.INIT">Current Status: {{ status }}</p>
-    <p v-if="message">
-      <span v-html="message"></span>
-    </p>
+    <p v-if="status != STATUS.INIT">Generation Status: {{ status }}</p>
     <p class="buttons">
-      <button v-if="canStop()" @click="stop()">Stop</button>
+      <button v-if="canCancel()" @click="cancel()">Cancel</button>
       <button v-else @click="start()">Generate VXML Now</button>
     </p>
     <p class="progressBar">
-      <a-progress :percent="percent" />
+      <a-progress :percent="percent" :status="progressBarStatus()" />
+    </p>
+    <p v-if="directory">
+      <span>Directory created: {{ directory }}</span>
+      &nbsp;
+      <button @click="copyDirectory()">Copy</button>
+    </p>
+    <p v-if="message">{{ message }}</p>
+    <p v-if="localeId">
+      Wrote locale: {{ localeId }} ({{ localesDone }} / {{ localesTotal }})
     </p>
-    <p v-html="output"></p>
+    <p v-if="verificationStatus">
+      Verification Status: {{ verificationStatus }}
+    </p>
+    <div v-if="verificationFailures?.length">
+      <h2 class="sectionHeader">Verification Failures</h2>
+      <p v-for="msg of verificationFailures" :key="msg">{{ msg }}</p>
+    </div>
+    <div v-if="verificationWarnings?.length">
+      <h2 class="sectionHeader">Verification Warnings</h2>
+      <p v-for="msg of verificationWarnings" :key="msg">{{ msg }}</p>
+    </div>
   </div>
 </template>
 
@@ -72,4 +125,11 @@ defineExpose({
 .progressBar {
   width: 50%;
 }
+
+.sectionHeader {
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+  font-size: 20px;
+}
 </style>
diff --git a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/OutputFileManager.java b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/OutputFileManager.java
index 408aaa5ffd8..ec6eb901377 100644
--- a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/OutputFileManager.java
+++ b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/OutputFileManager.java
@@ -18,7 +18,6 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
-import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.time.Instant;
@@ -86,9 +85,9 @@ private static class DirNames {
      * Generate VXML
      *
      * @param vxmlGenerator the VxmlGenerator
-     * @param out the Writer to receive output
+     * @param results the VxmlQueue.Results
      */
-    public static void generateVxml(VxmlGenerator vxmlGenerator, Writer out) {
+    public static void generateVxml(VxmlGenerator vxmlGenerator, VxmlQueue.Results results) {
         try {
             /*
              * Sync on OutputFileManager.class here prevents re-entrance if invoked repeatedly before completion.
@@ -96,27 +95,22 @@ public static void generateVxml(VxmlGenerator vxmlGenerator, Writer out) {
             synchronized (OutputFileManager.class) {
                 SurveyMain sm = CookieSession.sm;
                 OutputFileManager ofm = sm.getOutputFileManager();
-                File vetdataDir = sm.getVetdir();
-                vetdataDir = createNewManualVetdataDir(vetdataDir);
-                if (vetdataDir == null) {
-                    out.write("Directory creation for vetting data failed.");
+                results.directory = createNewManualVetdataDir(sm.getVetdir());
+                if (results.directory == null) {
+                    results.generationMessage = "Directory creation for vetting data failed.";
                     return;
                 }
-                // TODO: make the directory name a separate field of the http response.
-                // In the meantime, it is still part of the html written to "out".
-                // Reference: https://unicode-org.atlassian.net/browse/CLDR-14913
-                out.write("<p>Created new directory: " + vetdataDir + "</p>");
-                if (!ofm.outputAllFiles(vxmlGenerator, out, vetdataDir)) {
-                    out.write("File output failed.");
+                if (!ofm.outputAllFiles(vxmlGenerator, results)) {
+                    results.generationMessage = "File output failed.";
                     return;
                 }
-                if (!ofm.copyDtd(vetdataDir)) {
-                    out.write("Copying DTD failed.");
+                if (!ofm.copyDtd(results.directory)) {
+                    results.generationMessage = "Copying DTD failed.";
                     return;
                 }
-                File vxmlDir = new File(vetdataDir + "/" + Kind.vxml.name());
+                File vxmlDir = new File(results.directory + "/" + Kind.vxml.name());
                 ofm.removeEmptyFiles(vxmlDir);
-                ofm.verifyAllFiles(vxmlGenerator, out, vxmlDir);
+                ofm.verifyAllFiles(results, vxmlDir);
             }
             logger.log(Level.WARNING, "generateVxml finished");
         } catch (Exception e) {
@@ -196,36 +190,21 @@ private boolean copyDtd(File vetdataDir) {
      * Output all files (VXML, etc.)
      *
      * @param vxmlGenerator the VxmlGenerator
-     * @param out the Writer, to receive HTML output
-     * @param vetDataDir the folder in which to write
+     * @param results the VxmlQueue.Results
      * @return true for success, false for failure
      */
-    private boolean outputAllFiles(VxmlGenerator vxmlGenerator, Writer out, File vetDataDir) {
+    private boolean outputAllFiles(VxmlGenerator vxmlGenerator, VxmlQueue.Results results) {
         try {
-            // TODO: instead of generating html on the back end, send structured data to the
-            // front end, including the generated list of locales as an array; or possibly just
-            // the number of locales written so far, along with most recent locale name.
-            // In the meantime, write a paragraph containing a comma-separated list of locale base
-            // names.
-            // Reference: https://unicode-org.atlassian.net/browse/CLDR-14913
-            out.write("<p>");
-            Set<CLDRLocale> sortSet = vxmlGenerator.getSortSet();
-            int i = 0;
-            for (CLDRLocale loc : sortSet) {
-                if (i++ > 0) {
-                    out.write(", ");
-                }
-                out.write(loc.getBaseName());
+            for (CLDRLocale loc : vxmlGenerator.getLocales()) {
                 for (OutputFileManager.Kind kind : OutputFileManager.Kind.values()) {
                     if (kind == OutputFileManager.Kind.vxml
                             || kind == OutputFileManager.Kind.pxml) {
                         logger.log(Level.WARNING, "Writing " + loc.getDisplayName() + ":" + kind);
-                        writeManualOutputFile(vetDataDir, loc, kind);
+                        writeManualOutputFile(results.directory, loc, kind);
                     }
                 }
                 vxmlGenerator.update(loc);
             }
-            out.write("</p>");
             return true;
         } catch (Exception e) {
             logger.log(Level.SEVERE, "outputAllFiles: " + e.getMessage(), e);
@@ -319,7 +298,7 @@ private void removeEmptyFiles(File vxmlDir) throws IOException {
      * Remove "empty" VXML files in the given directory
      *
      * @param dirFile the given directory
-     * @throws IOException
+     * @throws IOException failed IO
      */
     private void removeEmptyFilesOneDir(File dirFile) throws IOException {
         Set<String> treatAsNonEmpty = new HashSet<>();
@@ -370,7 +349,7 @@ private void removeEmptyFilesOneDir(File dirFile) throws IOException {
     /**
      * Add the given name, and the names of its ancestors (except root), to the given set
      *
-     * @param treatAsNonEmpty
+     * @param treatAsNonEmpty the set to be modified
      * @param name the xml file name (without the .xml extension)
      */
     private static void addNameAndParents(Set<String> treatAsNonEmpty, String name) {
@@ -384,51 +363,35 @@ private static void addNameAndParents(Set<String> treatAsNonEmpty, String name)
     /**
      * Verify all VXML files
      *
-     * @param vxmlGenerator the VxmlGenerator
-     * @param out the Writer, to receive HTML output
+     * @param results the VxmlQueue.Results
      *     <p>The following need to be verified on the server when generating vxml: • The same file
      *     must not occur in both the common/X and seed/X directories, for any X=main|annotations •
      *     If a parent locale (except for root) must occur in the same directory as the child locale
      *     • Every file in trunk (common|seed/X) must have a corresponding vxml file • Every file in
      *     vxml (common|seed/X) must have a corresponding trunk file This should fail with clear
      *     warning to the user that there is a major problem. Reference: CLDR-12016
-     * @throws IOException
-     *     <p>vetdata └── vxml    ├── common    │   ├── annotations    │   └── main    └── seed ├──
-     *     annotations    └── main
      */
-    private void verifyAllFiles(VxmlGenerator vxmlGenerator, Writer out, File vxmlDir)
-            throws IOException {
-        int failureCount = 0;
-
+    private void verifyAllFiles(VxmlQueue.Results results, File vxmlDir) {
         /*
          * The same file must not occur in both the common/X and seed/X directories, for any X=main|annotations
          */
-        if (!verifyNoDuplicatesInCommonAndSeed(out, vxmlDir)) {
-            ++failureCount;
-        }
+        verifyNoDuplicatesInCommonAndSeed(results, vxmlDir);
+
         /*
          * A parent locale (except for root) must occur in the same directory as the child locale
          */
-        if (!verifyParentChildSameDirectory(out, vxmlDir)) {
-            ++failureCount;
-        }
+        verifyParentChildSameDirectory(results, vxmlDir);
+
         /*
          * Every file in trunk (common|seed/X) must have a corresponding vxml file
          * Every file in vxml (common|seed/X) must have a corresponding trunk file
          */
-        if (!verifyVxmlAndBaselineFilesCorrespond(out, vxmlDir)) {
-            ++failureCount;
-        }
+        verifyVxmlAndBaselineFilesCorrespond(results, vxmlDir);
 
-        if (failureCount == 0) {
-            out.write("<h1>✅ VXML verification succeeded</h1>\nOK<br>");
-            vxmlGenerator.setVerificationStatus(VxmlGenerator.VerificationStatus.SUCCESSFUL);
+        if (results.verificationFailures.isEmpty()) {
+            results.setVerificationStatus(VxmlGenerator.VerificationStatus.SUCCESSFUL);
         } else {
-            out.write(
-                    "<h1>❌ VXML verification failed!</h1>\nFailure count = "
-                            + failureCount
-                            + "<br>");
-            vxmlGenerator.setVerificationStatus(VxmlGenerator.VerificationStatus.FAILED);
+            results.setVerificationStatus(VxmlGenerator.VerificationStatus.FAILED);
         }
     }
 
@@ -436,12 +399,9 @@ private void verifyAllFiles(VxmlGenerator vxmlGenerator, Writer out, File vxmlDi
      * Verify that the same file does not occur in both the common/X and seed/X directories, for any
      * X=main|annotations
      *
-     * @param out the Writer, to receive HTML output
-     * @return true if verification succeeded, false for failure
-     * @throws IOException
+     * @param results the VxmlQueue.Results
      */
-    private boolean verifyNoDuplicatesInCommonAndSeed(Writer out, File vxmlDir) throws IOException {
-
+    private void verifyNoDuplicatesInCommonAndSeed(VxmlQueue.Results results, File vxmlDir) {
         for (String m : DirNames.mainAndAnnotations) {
             String commonDirName = vxmlDir + "/" + DirNames.justCommon + "/" + m;
             String seedDirName = vxmlDir + "/" + DirNames.justSeed + "/" + m;
@@ -453,18 +413,13 @@ private boolean verifyNoDuplicatesInCommonAndSeed(Writer out, File vxmlDir) thro
                     String seedPathName = seedDirName + "/" + commonName;
                     File fSeed = new File(seedPathName);
                     if (fSeed.exists()) {
-                        out.write(
-                                "<h2>Verification failure, found duplicates</h2>\n"
-                                        + commonPathName
-                                        + "<br>\n"
-                                        + seedPathName
-                                        + "<br>\n");
-                        return false;
+                        results.addVerificationFailure(
+                                "Found duplicates: " + commonPathName + " - " + seedPathName);
+                        return;
                     }
                 }
             }
         }
-        return true;
     }
 
     /**
@@ -475,12 +430,9 @@ private boolean verifyNoDuplicatesInCommonAndSeed(Writer out, File vxmlDir) thro
      * "ff_Adlm_BF.xml" we should have "ff_Adlm.xml" in the same folder Note handling of two
      * underscores in "ff_Adlm_BF.xml"
      *
-     * @param out the Writer, to receive HTML output
-     * @return true if verification succeeded, false for failure
-     * @throws IOException
+     * @param results the VxmlQueue.Results
      */
-    private boolean verifyParentChildSameDirectory(Writer out, File vxmlDir) throws IOException {
-
+    private void verifyParentChildSameDirectory(VxmlQueue.Results results, File vxmlDir) {
         for (String c : DirNames.commonAndSeed) {
             for (String m : DirNames.mainAndAnnotations) {
                 String dirName = vxmlDir + "/" + c + "/" + m;
@@ -498,11 +450,9 @@ private boolean verifyParentChildSameDirectory(Writer out, File vxmlDir) throws
                     String localeName = childName.replaceFirst("\\.xml$", "");
                     CLDRLocale childLoc = CLDRLocale.getInstance(localeName);
                     if (childLoc == null) {
-                        out.write(
-                                "<h2>Verification failure, locale not recognized from file name</h2>\n"
-                                        + childPathName
-                                        + "<br>\n");
-                        return false;
+                        results.addVerificationFailure(
+                                "Locale not recognized from file name: " + childPathName);
+                        return;
                     }
                     CLDRLocale parLoc = childLoc.getParent();
                     if (parLoc != null) {
@@ -513,22 +463,20 @@ private boolean verifyParentChildSameDirectory(Writer out, File vxmlDir) throws
                             String parentPathName = dirName + "/" + parentName;
                             File fParent = new File(parentPathName);
                             if (!fParent.exists() && !otherParentExists(parentPathName, c)) {
-                                out.write(
-                                        "<h2>Verification failure, child without parent</h2>\n"
+                                results.addVerificationFailure(
+                                        "Child without parent. "
                                                 + "Child, present: "
                                                 + childPathName
-                                                + "<br>\n"
+                                                + " - "
                                                 + "Parent, absent: "
-                                                + parentPathName
-                                                + "<br>\n");
-                                return false;
+                                                + parentPathName);
+                                return;
                             }
                         }
                     }
                 }
             }
         }
-        return true;
     }
 
     /**
@@ -566,13 +514,9 @@ private boolean otherParentExists(String parentPathName, String commonOrSeed) {
      * required, and only results in a notification (new files in vxml are to be expected from time
      * to time).
      *
-     * @param out the Writer, to receive HTML output
-     * @return true if verification succeeded, false for failure
-     * @throws IOException
+     * @param results the VxmlQueue.Results
      */
-    private boolean verifyVxmlAndBaselineFilesCorrespond(Writer out, File vxmlDir)
-            throws IOException {
-
+    private void verifyVxmlAndBaselineFilesCorrespond(VxmlQueue.Results results, File vxmlDir) {
         String bxmlDir = CLDRConfig.getInstance().getCldrBaseDirectory().toString();
         ArrayList<String> vxmlFiles = new ArrayList<>();
         ArrayList<String> bxmlFiles = new ArrayList<>(); /* bxml = baseline cldr xml */
@@ -609,33 +553,33 @@ private boolean verifyVxmlAndBaselineFilesCorrespond(Writer out, File vxmlDir)
                 /*
                  * Notification only, not a failure
                  */
-                out.write(
-                        "<h2>Verification notice, file(s) present in vxml but not in baseline</h2>\n");
+                StringBuilder message =
+                        new StringBuilder("File(s) present in VXML but not in baseline:");
                 for (String name : diff) {
                     if (vxmlFiles.contains(name)) {
-                        out.write(name + "<br>\n");
+                        message.append(" ").append(name);
                     }
                 }
+                results.addVerificationWarning(message.toString());
             }
             if (someOnlyInBxml) {
-                out.write(
-                        "<h2>Verification failure, file(s) present in baseline but not in vxml</h2>\n");
+                StringBuilder message =
+                        new StringBuilder("File(s) present in baseline but not in VXML:");
                 for (String name : diff) {
                     if (bxmlFiles.contains(name)) {
-                        out.write(name + "<br>\n");
+                        message.append(" ").append(name);
                     }
                 }
-                return false;
+                results.addVerificationFailure(message.toString());
             }
         }
-        return true;
     }
 
     /**
      * Return the set of all strings that are in one list but not the other
      *
-     * @param list1
-     * @param list2
+     * @param list1 the first list
+     * @param list2 the second list
      * @return the Set
      */
     private static Set<String> symmetricDifference(
@@ -660,8 +604,8 @@ private static Set<String> symmetricDifference(
      *
      * @param file the CLDRFile for reading
      * @param outFile the File for "main"; another file will be created in "annotations"
-     * @throws UnsupportedEncodingException
-     * @throws FileNotFoundException
+     * @throws UnsupportedEncodingException for bad encoding, unlikely for UTF-8
+     * @throws FileNotFoundException for file error
      */
     private void doWriteFile(CLDRFile file, Kind kind, File outFile)
             throws UnsupportedEncodingException, FileNotFoundException {
@@ -702,10 +646,10 @@ private static File makeAnnotationFile(File outFile) {
     /**
      * For a request like ".../cldr-apps/survey/vxml/main/aa.xml", respond with the xml
      *
-     * @param request
-     * @param response
+     * @param request the HttpServletRequest
+     * @param response the HttpServletResponse
      * @return true if request is for a kind of xml we can provide, else false.
-     * @throws IOException
+     * @throws IOException for WebContext failure
      */
     public boolean doRawXml(HttpServletRequest request, HttpServletResponse response)
             throws IOException {
diff --git a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlGenerator.java b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlGenerator.java
index ede57368c03..dd9e72990ba 100644
--- a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlGenerator.java
+++ b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlGenerator.java
@@ -1,24 +1,27 @@
 package org.unicode.cldr.web;
 
-import java.io.Writer;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import org.unicode.cldr.util.CLDRLocale;
 
 public class VxmlGenerator {
-    public void generate(Set<CLDRLocale> sortSet, Writer out) throws ExecutionException {
-        this.sortSet = sortSet;
+
+    private final Set<CLDRLocale> locales;
+
+    public VxmlGenerator() {
+        this.locales = OutputFileManager.createVxmlLocaleSet();
+    }
+
+    public void generate(VxmlQueue.Results results) throws ExecutionException {
         try {
-            OutputFileManager.generateVxml(this, out);
+            OutputFileManager.generateVxml(this, results);
         } catch (Exception e) {
             throw new ExecutionException(e);
         }
     }
 
-    private Set<CLDRLocale> sortSet = null;
-
-    public Set<CLDRLocale> getSortSet() {
-        return sortSet;
+    public Set<CLDRLocale> getLocales() {
+        return locales;
     }
 
     public enum VerificationStatus {
@@ -27,16 +30,6 @@ public enum VerificationStatus {
         INCOMPLETE
     }
 
-    private VerificationStatus verificationStatus = VerificationStatus.INCOMPLETE;
-
-    public VerificationStatus getVerificationStatus() {
-        return verificationStatus;
-    }
-
-    public void setVerificationStatus(VerificationStatus status) {
-        verificationStatus = status;
-    }
-
     /**
      * Class that allows the relaying of progress information. Extended by
      * VxmlQueue.Task.VxmlProgressCallback
diff --git a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlQueue.java b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlQueue.java
index e947da456db..5acb0912518 100644
--- a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlQueue.java
+++ b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/VxmlQueue.java
@@ -1,7 +1,6 @@
 package org.unicode.cldr.web;
 
-import java.io.IOException;
-import java.io.StringWriter;
+import java.io.File;
 import java.time.LocalTime;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
@@ -13,6 +12,13 @@ public class VxmlQueue {
     private static final Logger logger = SurveyLog.forClass(VxmlQueue.class);
 
     private static final String WAITING_IN_LINE_MESSAGE = "Waiting in line";
+    private static final String VXML_MESSAGE_STOPPED_ON_REQUEST = "Stopped on request";
+    private static final String VXML_MESSAGE_STARTED = "Started new task";
+    private static final String VXML_MESSAGE_PROGRESS = "In Progress";
+    private static final String VXML_MESSAGE_STOPPED_STUCK = "Stopped (refresh if stuck)";
+    private static final String VXML_MESSAGE_NOT_LOADING = "Not loading";
+    private static final String VXML_MESSAGE_SUCCESS = "Successful completion";
+    private static final String VXML_MESSAGE_PROBLEM = "Problem(s) occurred";
 
     private static final class VxmlQueueHelper {
         static VxmlQueue instance = new VxmlQueue();
@@ -30,33 +36,36 @@ public static VxmlQueue getInstance() {
     /** A unique key for storing QueueEntry objects in QueueMemberId objects */
     private static final String KEY = VxmlQueue.class.getName();
 
-    /** Status of a Task */
     public enum Status {
         /** Waiting on other users/tasks */
         WAITING,
         /** Processing in progress */
         PROCESSING,
-        /** Contents are available */
-        READY,
-        /** Stopped, due to error or cancellation (LoadingPolicy.STOP) */
+        /** Contents are available and successfully validated */
+        SUCCEEDED,
+        /** Stopped, due to error, validation failure, or cancellation */
         STOPPED,
     }
 
-    /** What policy should be used when querying the queue? */
-    public enum LoadingPolicy {
+    public enum RequestType {
         /** Start a new VXML generation task */
         START,
         /** Continue the task already in progress and get its status */
         CONTINUE,
-        /** Stop (cancel) the task in progress. */
-        STOP
+        /** Cancel (stop) the task */
+        CANCEL
     }
 
     private static class QueueEntry {
-        public VxmlGenerator.VerificationStatus verificationStatus =
-                VxmlGenerator.VerificationStatus.INCOMPLETE;
+        public Results results = new Results();
         private Task currentTask = null;
         private Boolean done = false;
+
+        void reset() {
+            results = new Results();
+            currentTask = null;
+            done = false;
+        }
     }
 
     /** Semaphore to ensure that only one vetter generates VXML at a time. */
@@ -84,7 +93,8 @@ public void nudge(CLDRLocale loc) {
                 if (!myThread.isAlive()) {
                     throw new RuntimeException("The thread is not running. Stop now.");
                 }
-                setStatus(loc.getDisplayName());
+                setLocale(loc);
+                setStatusMessage("Writing VXML files");
                 n++;
             }
 
@@ -99,107 +109,144 @@ public boolean isStopped() {
         private final QueueEntry entry;
         private int maxn;
         private int n = 0;
-        private String status = WAITING_IN_LINE_MESSAGE;
         private Status statusCode = Status.WAITING;
+        private String statusMessage = WAITING_IN_LINE_MESSAGE;
 
-        private void setStatus(String status) {
-            this.status = status;
+        private void setStatusMessage(String status) {
+            this.statusMessage = status;
         }
 
-        private final StringWriter output = new StringWriter();
+        private CLDRLocale loc;
+
+        public CLDRLocale getLocale() {
+            return loc;
+        }
+
+        private void setLocale(CLDRLocale loc) {
+            this.loc = loc;
+        }
 
         @Override
         public void run() {
             statusCode = Status.WAITING;
             try {
-                status = "Waiting...";
+                setStatusMessage("Waiting...");
                 OnlyOneVetter.acquire();
                 try {
-                    if (stop) {
-                        doStop();
-                        return;
-                    }
-                    processCriticalWork();
-                    if (stop) {
-                        doStop();
-                        return;
-                    }
+                    makeVxml();
                 } finally {
                     OnlyOneVetter.release();
                 }
-                status = "Finished.";
-                statusCode = Status.READY;
+                if (stop) {
+                    setStatusMessage("Stopped on request.");
+                    statusCode = Status.STOPPED;
+                } else {
+                    setStatusMessage("Finished.");
+                    statusCode = Status.SUCCEEDED;
+                }
             } catch (RuntimeException | InterruptedException | ExecutionException re) {
                 SurveyLog.logException(logger, re, "While generating VXML, " + taskDescription());
-                status = "Exception! " + re + ", " + taskDescription();
+                setStatusMessage("Exception! " + re + ", " + taskDescription());
                 statusCode = Status.STOPPED;
             }
         }
 
-        private void doStop() {
-            status = "Stopped on request.";
-            statusCode = Status.STOPPED;
-        }
-
-        private String taskDescription() {
-            return "thread " + myThread.getId() + ", " + LocalTime.now();
-        }
-
-        private void processCriticalWork() throws ExecutionException {
-            status = "Beginning";
-            Set<CLDRLocale> sortSet = OutputFileManager.createVxmlLocaleSet();
-            maxn = sortSet.size();
+        private void makeVxml() throws ExecutionException {
+            setStatusMessage("Beginning");
             statusCode = Status.PROCESSING;
-            n = 0;
             VxmlGenerator vg = new VxmlGenerator();
+            n = 0;
+            maxn = vg.getLocales().size();
             vg.setProgressCallback(new VxmlProgressCallback(Thread.currentThread()));
-            vg.generate(sortSet, output);
-            entry.verificationStatus = vg.getVerificationStatus();
+            vg.generate(entry.results);
             entry.done = true;
         }
 
+        private String taskDescription() {
+            return "thread " + myThread.getId() + ", " + LocalTime.now();
+        }
+
         private int getPercent() {
-            if (n <= 0 || maxn <= 0) {
-                return 0;
-            } else if (n >= maxn) {
-                return 100;
-            } else {
-                int p = (n * 100) / maxn;
-                return (p > 0) ? p : 1;
-            }
+            return CompletionPercent.calculate(n, maxn);
         }
     }
 
-    /** Arguments for getOutput */
     public static class Args {
         private final QueueMemberId qmi;
-        private final LoadingPolicy loadingPolicy;
+        private final RequestType requestType;
 
-        public Args(QueueMemberId qmi, LoadingPolicy loadingPolicy) {
+        public Args(QueueMemberId qmi, RequestType requestType) {
             this.qmi = qmi;
-            this.loadingPolicy = loadingPolicy;
+            this.requestType = requestType;
         }
     }
 
-    /**
-     * Results for getOutput
-     *
-     * <p>These fields get filled in by getOutput, and referenced by the caller after getOutput
-     * returns
-     */
     public static class Results {
         public Status status = Status.WAITING;
-        public Appendable output = new StringBuilder();
-    }
 
-    /*
-     * Messages returned by getOutput
-     */
-    private static final String VXML_MESSAGE_STOPPED_ON_REQUEST = "Stopped on request";
-    private static final String VXML_MESSAGE_PROGRESS = "In Progress";
-    private static final String VXML_MESSAGE_STOPPED_STUCK = "Stopped (refresh if stuck)";
-    private static final String VXML_MESSAGE_NOT_LOADING = "Not loading. Click the button to load.";
-    private static final String VXML_MESSAGE_STARTED = "Started new task";
+        public String generationMessage;
+
+        public File directory;
+
+        private int percent = 0;
+
+        public Number getPercent() {
+            return this.percent;
+        }
+
+        public void setPercent(int i) {
+            this.percent = i;
+        }
+
+        private CLDRLocale locale;
+
+        public CLDRLocale getLocale() {
+            return locale;
+        }
+
+        public void setLocale(CLDRLocale locale) {
+            this.locale = locale;
+        }
+
+        private int localesDone = 0;
+
+        public int getLocalesDone() {
+            return localesDone;
+        }
+
+        public void setLocalesDone(int n) {
+            localesDone = n;
+        }
+
+        private int localesTotal = 0;
+
+        public int getLocalesTotal() {
+            return localesTotal;
+        }
+
+        public void setLocalesTotal(int n) {
+            localesTotal = n;
+        }
+
+        public VxmlGenerator.VerificationStatus verificationStatus =
+                VxmlGenerator.VerificationStatus.INCOMPLETE;
+
+        public void setVerificationStatus(VxmlGenerator.VerificationStatus vStatus) {
+            this.verificationStatus = vStatus;
+        }
+
+        public ArrayList<String> verificationFailures = new ArrayList<>();
+
+        public ArrayList<String> verificationWarnings = new ArrayList<>();
+
+        public void addVerificationFailure(String s) {
+            verificationFailures.add(s);
+        }
+
+        public void addVerificationWarning(String s) {
+            verificationWarnings.add(s);
+        }
+    }
 
     /**
      * Start running, or continue running, the long-running task that generates VXML. This is called
@@ -207,70 +254,82 @@ public static class Results {
      * subsequent requests that query the status or trigger early termination of the task.
      *
      * @param args the VxmlQueue.Args
-     * @param results the VxmlQueue.Results
-     * @return the status message
-     * @throws IOException if thrown by results.output.append
+     * @return the Results
      */
-    public synchronized String getOutput(Args args, Results results) throws IOException {
+    public synchronized Results getResults(Args args) {
         QueueEntry entry = getEntry(args.qmi);
-        Task t = entry.currentTask;
-        if (t == null) {
-            logger.info("Got null Task in getOutput");
+        if (args.requestType == RequestType.START) {
+            getResultsStart(entry);
+        } else if (args.requestType == RequestType.CONTINUE) {
+            getResultsContinue(entry);
+        } else if (args.requestType == RequestType.CANCEL) {
+            getResultsStop(entry);
         } else {
-            results.output.append(t.output.toString());
+            logger.severe("Invalid request type for VXML, treating as STOP: " + args.requestType);
+            getResultsStop(entry);
         }
-        if (args.loadingPolicy == LoadingPolicy.STOP) {
-            stop(entry);
-            results.status = Status.STOPPED;
-            return VXML_MESSAGE_STOPPED_ON_REQUEST;
-        } else if (entry.done) {
-            if (entry.verificationStatus == VxmlGenerator.VerificationStatus.SUCCESSFUL) {
-                results.status = Status.READY;
-                setPercent(100);
+        return entry.results;
+    }
+
+    private void getResultsStart(QueueEntry entry) {
+        entry.reset();
+        // Note: similar code in VettingViewerQueue.getPriorityItemsSummaryOutput includes
+        // a comment suggesting an alternative: SurveyThreadManager.getExecutorService().invoke()
+        Task t = entry.currentTask = new Task(entry);
+        t.myThread = SurveyThreadManager.getThreadFactory().newThread(t);
+        t.myThread.start();
+        entry.results.status = Status.PROCESSING;
+        final String waitStr = waitingString();
+        if (WAITING_IN_LINE_MESSAGE.equals(t.statusMessage) && waitStr.isEmpty()) {
+            // Simplify “Started new task: Waiting in line” to "Waiting in line"
+            entry.results.generationMessage = WAITING_IN_LINE_MESSAGE;
+        } else {
+            entry.results.generationMessage =
+                    VXML_MESSAGE_STARTED + ": " + waitStr + t.statusMessage;
+        }
+    }
+
+    private void getResultsContinue(QueueEntry entry) {
+        Task t = entry.currentTask;
+        if (t != null) {
+            entry.results.setLocale(t.getLocale());
+            entry.results.setLocalesDone(t.n);
+            entry.results.setLocalesTotal(t.maxn);
+            entry.results.setPercent(t.getPercent());
+        }
+        if (entry.done) {
+            if (entry.results.verificationStatus == VxmlGenerator.VerificationStatus.SUCCESSFUL) {
+                entry.results.status = Status.SUCCEEDED;
+                entry.results.generationMessage = VXML_MESSAGE_SUCCESS;
             } else {
-                results.status = Status.STOPPED;
-                if (getPercent() > 99) {
-                    setPercent(99);
-                }
+                entry.results.status = Status.STOPPED;
+                entry.results.generationMessage = VXML_MESSAGE_PROBLEM;
             }
             stop(entry);
-            return entry.verificationStatus.toString();
-        }
-        if (t != null) {
+        } else if (t == null) {
+            entry.results.status = Status.STOPPED;
+            entry.results.generationMessage = VXML_MESSAGE_NOT_LOADING;
+        } else {
             String waiting = waitingString();
-            results.status = Status.PROCESSING;
+            entry.results.status = Status.PROCESSING;
             if (t.myThread.isAlive()) {
-                results.status = t.statusCode;
-                if (results.status != Status.WAITING) {
+                entry.results.status = t.statusCode;
+                if (entry.results.status != Status.WAITING) {
                     waiting = "";
                 }
-                setPercent(t.getPercent());
-                return VXML_MESSAGE_PROGRESS + ": " + waiting + t.status;
+                entry.results.generationMessage =
+                        VXML_MESSAGE_PROGRESS + ": " + waiting + t.statusMessage;
             } else {
-                setPercent(0);
-                return VXML_MESSAGE_STOPPED_STUCK + " " + t.status;
+                entry.results.generationMessage =
+                        VXML_MESSAGE_STOPPED_STUCK + " " + t.statusMessage;
             }
         }
-        if (args.loadingPolicy == LoadingPolicy.CONTINUE) {
-            results.status = Status.STOPPED;
-            setPercent(0);
-            return VXML_MESSAGE_NOT_LOADING;
-        }
-
-        // Note: similar code in VettingViewerQueue.getPriorityItemsSummaryOutput includes
-        // a comment suggesting an alternative: SurveyThreadManager.getExecutorService().invoke()
-        t = entry.currentTask = new Task(entry);
-        t.myThread = SurveyThreadManager.getThreadFactory().newThread(t);
-        t.myThread.start();
+    }
 
-        results.status = Status.PROCESSING;
-        setPercent(0);
-        final String waitStr = waitingString();
-        if (WAITING_IN_LINE_MESSAGE.equals(t.status) && waitStr.isEmpty()) {
-            // Simplify “Started new task: Waiting in line” to "Waiting in line"
-            return WAITING_IN_LINE_MESSAGE;
-        }
-        return VXML_MESSAGE_STARTED + ": " + waitStr + t.status;
+    private void getResultsStop(QueueEntry entry) {
+        stop(entry);
+        entry.results.status = Status.STOPPED;
+        entry.results.generationMessage = VXML_MESSAGE_STOPPED_ON_REQUEST;
     }
 
     private String waitingString() {
@@ -286,7 +345,6 @@ private void stop(QueueEntry entry) {
                 t.myThread.interrupt();
             }
             entry.currentTask = null;
-            entry.done = true;
         }
     }
 
@@ -298,15 +356,4 @@ private QueueEntry getEntry(QueueMemberId qmi) {
         }
         return entry;
     }
-
-    /** Estimated percentage complete for VXML generation */
-    private int percent = 0;
-
-    private void setPercent(int p) {
-        percent = p;
-    }
-
-    public int getPercent() {
-        return percent;
-    }
 }
diff --git a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/api/GenerateVxml.java b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/api/GenerateVxml.java
index 72a48ce6c29..7afa99a038d 100644
--- a/tools/cldr-apps/src/main/java/org/unicode/cldr/web/api/GenerateVxml.java
+++ b/tools/cldr-apps/src/main/java/org/unicode/cldr/web/api/GenerateVxml.java
@@ -11,6 +11,7 @@
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
 import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+import org.unicode.cldr.util.CLDRLocale;
 import org.unicode.cldr.web.*;
 
 @ApplicationScoped
@@ -59,7 +60,7 @@ public Response generateVxml(
             // concurrently with the vxml worker thread.
             CookieSession.sm.getSTFactory().setupDB();
             cs.userDidAction();
-            VxmlResponse vr = getVxmlResponse(request.loadingPolicy, cs);
+            VxmlResponse vr = getVxmlResponse(request.requestType, cs);
             return Response.ok(vr).build();
         } catch (Exception e) {
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
@@ -69,29 +70,36 @@ public Response generateVxml(
     /**
      * Get the response for VXML
      *
-     * @param loadingPolicy the LoadingPolicy
+     * @param requestType the RequestType
      * @param cs the CookieSession
      * @return the VxmlResponse
-     * @throws IOException if thrown by VxmlQueue.getOutput
+     * @throws IOException for getCanonicalPath failure
      */
-    private VxmlResponse getVxmlResponse(VxmlQueue.LoadingPolicy loadingPolicy, CookieSession cs)
+    private VxmlResponse getVxmlResponse(VxmlQueue.RequestType requestType, CookieSession cs)
             throws IOException {
         VxmlQueue queue = VxmlQueue.getInstance();
         QueueMemberId qmi = new QueueMemberId(cs);
         VxmlResponse response = new VxmlResponse();
-        VxmlQueue.Args args = new VxmlQueue.Args(qmi, loadingPolicy);
-        VxmlQueue.Results results = new VxmlQueue.Results();
-        response.message = queue.getOutput(args, results);
-        response.percent = queue.getPercent();
+        VxmlQueue.Args args = new VxmlQueue.Args(qmi, requestType);
+        VxmlQueue.Results results = queue.getResults(args);
+        response.message = results.generationMessage;
         response.status = results.status;
-        response.output = results.output.toString();
+        response.directory = results.directory == null ? "" : results.directory.getCanonicalPath();
+        CLDRLocale loc = results.getLocale();
+        response.localeId = loc == null ? "" : loc.getBaseName();
+        response.localesDone = results.getLocalesDone();
+        response.localesTotal = results.getLocalesTotal();
+        response.percent = results.getPercent();
+        response.verificationStatus = results.verificationStatus;
+        response.verificationFailures = results.verificationFailures.toArray(new String[0]);
+        response.verificationWarnings = results.verificationWarnings.toArray(new String[0]);
         return response;
     }
 
     @Schema(description = "VXML Request")
     public static final class VxmlRequest {
-        @Schema(implementation = VxmlQueue.LoadingPolicy.class)
-        public VxmlQueue.LoadingPolicy loadingPolicy;
+        @Schema(implementation = VxmlQueue.RequestType.class)
+        public VxmlQueue.RequestType requestType;
     }
 
     @Schema(description = "VXML Response")
@@ -102,10 +110,28 @@ public static final class VxmlResponse {
         @Schema(description = "Current status message")
         public String message = "";
 
+        @Schema(description = "Directory newly created to contain generated files")
+        public String directory;
+
+        @Schema(description = "Latest locale written")
+        public String localeId;
+
+        @Schema(description = "Locales written")
+        public int localesDone;
+
+        @Schema(description = "Total number of locales")
+        public int localesTotal;
+
         @Schema(description = "Estimated percentage complete")
         public Number percent;
 
-        @Schema(description = "Output on success")
-        public String output;
+        @Schema(description = "Verification status enum")
+        public VxmlGenerator.VerificationStatus verificationStatus;
+
+        @Schema(description = "Verification failure messages")
+        public String[] verificationFailures;
+
+        @Schema(description = "Verification warning messages")
+        public String[] verificationWarnings;
     }
 }