@mindline/sync 1.0.36 → 1.0.38

package/index.ts

@@ -1,7 +1,7 @@
 //index.ts - published interface - AAD implementations, facade to Mindline Config API
 import * as signalR from "@microsoft/signalr"
 import { IPublicClientApplication, AuthenticationResult } from "@azure/msal-browser"
-import { deserializeArray } from 'class-transformer';
+import { deserializeArray, instanceToPlain, ClassTransformOptions } from 'class-transformer';
 import { adminDelete, adminPost, adminsGet, configDelete, configsGet, configPost, configPut, graphConfig, initPost, readerPost, tenantPut, tenantPost, tenantDelete, tenantsGet, workspacesGet } from './hybridspa';
 import { version } from './package.json';
 import users from "./users.json";
@@ -9,6 +9,8 @@ import tenants from "./tenants.json";
 import configs from "./configs.json";
 import workspaces from "./workspaces.json";
 import tasksData from "./tasks";
+import syncmilestones from './syncmilestones';
+import { log } from "console";
 const FILTER_FIELD = "workspaceIDs";
 // called by unit tests
 export function sum(a: number, b: number): number {
@@ -42,7 +44,7 @@ export class User {
         this.oid = "";
         this.name = "";
         this.mail = "";
-        this.authority = "https://login.microsoftonline.com/organizations/v2.0";
+        this.authority = "";
         this.tid = "";
         this.companyName = "";
         this.companyDomain = "";
@@ -87,12 +89,20 @@ export class Tenant {
         this.tenantType = "aad";
         this.permissionType = "notassigned";
         this.onboarded = "false";
-        this.authority = "https://login.microsoftonline.com/organizations/v2.0";
+        this.authority = "";
         this.readServicePrincipal = "";
         this.writeServicePrincipal = "";
         this.workspaceIDs = "";
     }
 }
+function getGraphEndpoint(authority: string): string {
+    switch (authority) {
+        case graphConfig.authorityWW: return "https://graph.microsoft.com/";
+        case graphConfig.authorityUS: return "https://graph.microsoft.us/";
+        case graphConfig.authorityCN: return "https://microsoftgraph.chinacloudapi.cn/";
+        default: debugger; return "";
+    }
+}
 export enum TenantConfigType {
     source = 1,
     target = 2,
@@ -103,18 +113,24 @@ export class TenantConfigInfo {
     tid: string;
     sourceGroupId: string;
     sourceGroupName: string;
+    targetGroupId: string;
+    targetGroupName: string;
     configurationTenantType: TenantConfigTypeStrings;
     deltaToken: string;
-    filesWritten: number;
+    usersWritten: number;
     configId: string;
+    batchId: string;
     constructor() {
         this.tid = "";
         this.sourceGroupId = "";
         this.sourceGroupName = "";
+        this.targetGroupId = "";
+        this.targetGroupName = "";
         this.configurationTenantType = "source";
         this.deltaToken = "";
-        this.filesWritten = 0;
+        this.usersWritten = 0;
         this.configId = "";
+        this.batchId = "";
     }
 }
 export class Config {
@@ -426,8 +442,196 @@ export class Task {
     };
 }
 // class corresponding to an execution of a Config - a *TenantNode* for each source tenant, each with a *TenantNode* array of target tenants
+export class Milestone {
+    Run: number;
+    Start: Date;
+    startDisplay: string;
+    POST: Date;
+    postDisplay: string;
+    Read: Date;
+    readDisplay: string;
+    Write: Date;
+    writeDisplay: string;
+    Duration: Date;
+    durationDisplay: string;
+    constructor(run: number) {
+        this.Run = run;
+        this.start("");
+        this.POST = null;
+        this.postDisplay = "";
+        this.Read = null;
+        this.readDisplay = "";
+        this.Write = null;
+        this.writeDisplay = "";
+        this.Duration = null;
+        this.durationDisplay = "";
+    }
+    start(start: string): void {
+        start == "" ? this.Start = new Date() : this.Start = new Date(start);
+        this.startDisplay = `${this.Start.getMinutes().toString().padStart(2, "0")}:${this.Start.getSeconds().toString().padStart(2, "0")}`;
+    }
+    post(post: string): void {
+        post == "" ? this.POST = new Date() : this.POST = new Date(post);
+        this.postDisplay = `${this.POST.getMinutes().toString().padStart(2, "0")}:${this.POST.getSeconds().toString().padStart(2, "0")}`;
+    }
+    read(read: string): void {
+        read == "" ? this.Read = new Date() : this.Read = new Date(read);
+        this.readDisplay = `${this.Read.getMinutes().toString().padStart(2, "0")}:${this.Read.getSeconds().toString().padStart(2, "0")}`;
+    }
+    write(write: string): void {
+        write == "" ? this.Write = new Date() : this.Write = new Date(write);
+        this.writeDisplay = `${this.Write.getMinutes().toString().padStart(2, "0")}:${this.Write.getSeconds().toString().padStart(2, "0")}`;
+        this.Duration = new Date(this.Write.getTime() - this.Start.getTime());
+        this.durationDisplay = `${this.Duration.getMinutes().toString().padStart(2, "0")}:${this.Duration.getSeconds().toString().padStart(2, "0")}`;
+    }
+}
+export class MilestoneArray {
+    milestones: Milestone[];
+    constructor(bClearLocalStorage: boolean) {
+        this.init(bClearLocalStorage);
+    }
+    init(bClearLocalStorage: boolean): void {
+        // read from localstorage by default
+        if (storageAvailable("localStorage")) {
+            let result = localStorage.getItem("syncmilestones");
+            if (result != null && typeof result === "string" && result !== "") {
+                let milestonesString: string = result;
+                let milestones: Object [] = JSON.parse(milestonesString);
+                if (milestones.length !== 0) {
+                    if (bClearLocalStorage) {
+                        localStorage.removeItem("syncmilestones");
+                    }
+                    else {
+                        this.#initFromObjects(milestones);
+                        return;
+                    }
+                }
+            }
+        }
+        // if storage unavailable or we were just asked to clear, read from default syncmilestone file
+        this.#initFromObjects(syncmilestones);
+    }
+    save(): void {
+        let milestonesString: string = JSON.stringify(this.milestones);
+        if (storageAvailable("localStorage")) {
+            localStorage.setItem("syncmilestones", milestonesString);
+        }
+    }
+    // milestone tracking during a sync
+    start(setMilestones): void {
+        // we should always have a milestone array and a first milestone
+        if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
+        let currentRun: number = Number(this.milestones[0].Run);
+        // create a new milestone and prepend to front of array
+        let newMilestone: Milestone = new Milestone(currentRun+1);
+        this.milestones.unshift(newMilestone);
+        // re-define milestone array to trigger render
+        this.milestones = this.milestones.map((ms: Milestone) => {
+            let newms = new Milestone(ms.Run);
+            newms.Start = ms.Start;
+            newms.startDisplay = ms.startDisplay;
+            newms.POST = ms.POST;
+            newms.postDisplay = ms.postDisplay;
+            newms.Read = ms.Read;
+            newms.readDisplay = ms.readDisplay;
+            newms.Write = ms.Write;
+            newms.writeDisplay = ms.writeDisplay;
+            newms.Duration = ms.Duration;
+            newms.durationDisplay = ms.durationDisplay;
+            return newms;
+        });
+        setMilestones(this.milestones);
+        console.log(`Start milestone: ${this.milestones[0].Run}:${this.milestones[0].Start}`);
+    }
+    unstart(setMilestones): void {
+        // we should always have a milestone array and a first milestone
+        if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
+        let currentRun: number = Number(this.milestones[0].Run);
+        // remove first milestone from front of array
+        let removedMilestone: Milestone = this.milestones.shift();
+        // re-define milestone array to trigger render
+        this.milestones = this.milestones.map((ms: Milestone) => {
+            let newms = new Milestone(ms.Run);
+            newms.Start = ms.Start;
+            newms.startDisplay = ms.startDisplay;
+            newms.POST = ms.POST;
+            newms.postDisplay = ms.postDisplay;
+            newms.Read = ms.Read;
+            newms.readDisplay = ms.readDisplay;
+            newms.Write = ms.Write;
+            newms.writeDisplay = ms.writeDisplay;
+            newms.Duration = ms.Duration;
+            newms.durationDisplay = ms.durationDisplay;
+            return newms;
+        });
+        setMilestones(this.milestones);
+        console.log(`Unstart removed first milestone: ${removedMilestone.Run}:${removedMilestone.Start}`);
+    }
+    post(setMilestones): void {
+        // update the post value of the first milestone
+        if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
+        this.milestones[0].post("");
+        setMilestones(this.milestones);
+        console.log(`POST milestone: ${this.milestones[0].Run}:${this.milestones[0].POST}`);
+    }
+    read(setMilestones): void {
+        if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
+        this.milestones[0].read("");
+        setMilestones(this.milestones);
+        console.log(`Read milestone: ${this.milestones[0].Run}:${this.milestones[0].Read}`);
+    }
+    write(setMilestones): void {
+        if (this.milestones == null || this.milestones.length < 1) { debugger; return; }
+        this.milestones[0].write("");
+        // while we have >10 complete milestones, remove the last
+        while (this.milestones.length > 10) {
+            let removed: Milestone = this.milestones.pop();
+            console.log(`Removed milestone #${removed.Run}: ${removed.Start}`);
+        }
+        // save to localstorage
+        this.save();
+        // re-define milestone array to trigger render
+        this.milestones = this.milestones.map((ms: Milestone) => {
+            let newms = new Milestone(ms.Run);
+            newms.Start = ms.Start;
+            newms.startDisplay = ms.startDisplay;
+            newms.POST = ms.POST;
+            newms.postDisplay = ms.postDisplay;
+            newms.Read = ms.Read;
+            newms.readDisplay = ms.readDisplay;
+            newms.Write = ms.Write;
+            newms.writeDisplay = ms.writeDisplay;
+            newms.Duration = ms.Duration;
+            newms.durationDisplay = ms.durationDisplay;
+            return newms;
+        });
+        setMilestones(this.milestones);
+    }
+    #initFromObjects(milestones: Object[]): void {
+        if (milestones == null) {
+            this.milestones = new Array();
+        }
+        else {
+            this.milestones = milestones.map((milestone: Object) => {
+                let ms: Milestone = new Milestone(Number(milestone.Run));
+                ms.start(milestone.Start);
+                ms.post(milestone.POST);
+                ms.read(milestone.Read);
+                ms.write(milestone.Write);
+                return ms;
+            });
+        }
+    }
+}
 export class BatchArray {
     tenantNodes: TenantNode[];
+    pb_startTS: number;
+    pb_progress: number;
+    pb_increment: number;
+    pb_idle: number;
+    pb_idleMax: number;
+    pb_timer;
+    milestoneArray: MilestoneArray;
     constructor(
         config: Config | null,
         syncPortalGlobalState: InitInfo | null,
@@ -435,30 +639,36 @@ export class BatchArray {
     ) {
         this.tenantNodes = new Array<TenantNode>();
         this.init(config, syncPortalGlobalState, bClearLocalStorage);
+        this.pb_startTS = 0;
+        this.pb_progress = 0;
+        this.pb_increment = 0;
+        this.pb_timer = 0;
+        this.pb_idle = 0;
+        this.pb_idleMax = 0;
+        this.milestoneArray = new MilestoneArray(false);
     }
     // populate tenantNodes based on config tenants
     init(
-        config: Config | null,
+        config: Config | null | undefined,
         syncPortalGlobalState: InitInfo | null,
         bClearLocalStorage: boolean
     ): void {
         console.log(
-            `Calling BatchArray::init(config: "${config ? config.name : "null"
-            }", bClearLocalStorage: ${bClearLocalStorage ? "true" : "false"})`
+            `Calling BatchArray::init(config: "${config ? config.name : "null"}", bClearLocalStorage: ${bClearLocalStorage ? "true" : "false"})`
         );
-        // first clear batch  array
-        this.tenantNodes.length = 0;
-        // then clear localStorage if we have been asked to
+        // clear localStorage if we have been asked to
         if (bClearLocalStorage) {
-            if (storageAvailable("localStorage"))
+            if (storageAvailable("localStorage")) {
                 localStorage.removeItem(config.name);
+                this.milestoneArray.init(bClearLocalStorage);
+            }
         }
         // create BatchArray if passed Config and InitInfo
-        if (
-            config != null &&
+        if (config != null &&
             config.tenants != null &&
-            syncPortalGlobalState != null
-        ) {
+            syncPortalGlobalState != null) {
+            // clear batch array only if we have been passed something with which to replace it
+            this.tenantNodes.length = 0;
             // create a sourceTenantNode for each Source and SourceTarget
             config.tenants.map((tciPotentialSource: TenantConfigInfo) => {
                 if (
@@ -471,7 +681,8 @@ export class BatchArray {
                     if (sourceTenant != null) {
                         let sourceTenantNode: TenantNode = new TenantNode(
                             tciPotentialSource.tid,
-                            sourceTenant.name
+                            sourceTenant.name,
+                            tciPotentialSource.batchId
                         );
                         this.tenantNodes.push(sourceTenantNode);
                     } else {
@@ -499,7 +710,8 @@ export class BatchArray {
                             if (targetTenant != null) {
                                 let targetTenantNode: TenantNode = new TenantNode(
                                     tciPotentialTarget.tid,
-                                    targetTenant.name
+                                    targetTenant.name,
+                                    tciPotentialTarget.batchId
                                 );
                                 sourceTenantNode.targets.push(targetTenantNode);
                                 sourceTenantNode.expanded = true;
@@ -514,160 +726,257 @@ export class BatchArray {
                     }
                 });
             });
-            // then try localStorage to find any matching source tenant metrics
-            if (storageAvailable("localStorage")) {
-                let result = localStorage.getItem(config.name);
-                if (result != null && typeof result === "string" && result !== "") {
-                    // TODO: retrieve any relevant stored statistics from localStorage
-                    // let batchArrayString: string = result;
-                    // let batchArray: BatchArray = JSON.parse(batchArrayString);
-                    // batchArray.batches.map((batch: Batch) => {
-                    //   config.tenants.map((tciTarget: TenantConfigInfo) => {
-                    //     if(tciTarget.tid !== batch.tid) {
-                    //       let target: Target = new Target(tciTarget.tid);
-                    //       batch.targets.push(target);
-                    //     }
-                    //   });
-                    // });
-                }
-            }
         }
     }
-    /*
-    monitorSyncProgress(): void {
-        const connection = new signalR.HubConnectionBuilder()
-            .withUrl("https://dev-signalrdispatcher-westus.azurewebsites.net/?statsId=df9c2e0a-f6fe-43bb-a155-d51f66dffe0e")
-            .configureLogging(signalR.LogLevel.Information)
-            .build();
-
-        // when you get a message
-        connection.on("newMessage", function (message) {
-            console.log(message); // log the message
-            const item = JSON.parse(message); //parse it into an object
-            const statsarray = item.Stats; // get the array of statistics
-            const statskeys = Object.keys(statsarray); // get the keys of the array
-            const statsvalues = Object.values(statsarray); // get the values of the array
-            let statistics = ""; // initialize statistics
-            let total = 1;
-            let currentR = 0;
-            let currentW = 0;
-            let currentD = 0;
-            for (let j = 0; j < statskeys.length; j++) { 		// store the TotalCount and store as total
-                if (statskeys[j].endsWith("TotalCount")) {
-                    total = statsvalues[j];
+    initializeProgressBar(setSyncProgress, setConfigSyncResult, setIdleText, setMilestones): void {
+        this.pb_startTS = Date.now();
+        this.pb_progress = 0;
+        this.pb_increment = 1;
+        this.pb_idle = 0;
+        this.pb_idleMax = 0;
+        setIdleText(`No updates seen for ${this.pb_idle} seconds. [max idle: ${this.pb_idleMax}]`);
+        this.pb_timer = setInterval(() => {
+            // if we go 20 seconds without a signalR message, finish the sync
+            this.pb_idle = this.pb_idle + 1;
+            this.pb_idleMax = Math.max(this.pb_idle, this.pb_idleMax);
+            setIdleText(`No updates seen for ${this.pb_idle} seconds. [max idle: ${this.pb_idleMax}]`);
+            if (this.pb_idle >= 20) {
+                clearInterval(this.pb_timer);
+                if (this.milestoneArray.milestones[0].Write == null) {
+                    this.milestoneArray.write(setMilestones);
                 }
-                if (statskeys[j].endsWith("CurrentCount")) { 	// store the Reader value as currentR
-                    if (statskeys[j].startsWith("Reader")) {
-                        currentR = statsvalues[j];
+                setConfigSyncResult(`finished sync, no updates for ${this.pb_idle} seconds`);
+            }
+            // if we get to 100, stop the timer, let SignalR or countdown timer finish sync
+            if (this.pb_progress < 100) {
+                this.pb_progress = Math.min(100, this.pb_progress + this.pb_increment);
+                setSyncProgress(this.pb_progress);
+            }
+        }, 1000);
+        this.milestoneArray.start(setMilestones);
+    }
+    uninitializeProgressBar(setSyncProgress, setConfigSyncResult, setIdleText, setMilestones): void {
+        this.pb_startTS = 0;
+        this.pb_progress = 0;
+        setSyncProgress(this.pb_progress);
+        setConfigSyncResult("sync failed to execute");
+        this.pb_increment = 0;
+        clearInterval(this.pb_timer);
+        this.pb_timer = 0;
+        this.pb_idle = 0;
+        this.pb_idleMax = 0;
+        setIdleText(`No updates seen for ${this.pb_idle} seconds. [max idle: ${this.pb_idleMax}]`);
+        this.milestoneArray.unstart(setMilestones);
+    }
+    initializeSignalR(
+        config: Config | null | undefined,
+        syncPortalGlobalState: InitInfo | null,
+        batchIdArray: Array<Object>,
+        setRefreshDeltaTrigger,
+        setReadersTotal,
+        setReadersCurrent,
+        setWritersTotal,
+        setWritersCurrent,
+        setMilestones,
+        setConfigSyncResult,
+        bClearLocalStorage: boolean
+    ): void {
+        // we have just completed a successful POST to startSync
+        this.milestoneArray.post(setMilestones);
+        setConfigSyncResult("started sync, waiting for updates...");
+        // re-initialize batch array with Configuration updated by the succcessful POST to startSync
+        this.init(config, syncPortalGlobalState, false);
+        // define newMessage handler that can access *this*
+        let handler = (message) => {
+            console.log(message);
+            let item = JSON.parse(message);
+            // reset the countdown timer every time we get a message
+            this.pb_idle = 0;
+            // find the associated tenant for this SignalR message
+            let matchingPair: Object = batchIdArray.find((o: Object) => o.BatchId == item.TargetID);
+            if (matchingPair == null) {
+                console.log(`Batch ${item.TargetID} not found in batchIdArray.`);
+                debugger;
+                return;
+            }
+            let tenantNode: TenantNode = this.tenantNodes.find((t: TenantNode) => t.tid === matchingPair.SourceId);
+            if (tenantNode == null) { // null OR undefined
+                console.log(`Tenant ${matchingPair.SourceId} not found in BatchArray.`);
+                debugger;
+                return;
+            }
+            tenantNode.batchId = matchingPair.BatchId;
+            // process stats for this SignalR message batch
+            let statsarray = item.Stats; // get the array of statistics
+            let statskeys = Object.keys(statsarray); // get the keys of the array
+            let statsvalues = Object.values(statsarray); // get the values of the array
+            for (let j = 0; j < statskeys.length; j++) {
+                let bTotalCount = statskeys[j].endsWith("TotalCount");
+                let bCurrentCount = statskeys[j].endsWith("CurrentCount");
+                let bDeferredCount = statskeys[j].endsWith("DeferredCount");
+                if (statskeys[j].startsWith("Reader")) {
+                    // parse tid from Reader key
+                    let tidRegexp = /Reader\/TID:(.+)\/TotalCount/;
+                    if (bCurrentCount) tidRegexp = /Reader\/TID:(.+)\/CurrentCount/;
+                    if (bDeferredCount) tidRegexp = /Reader\/TID:(.+)\/DeferredCount/;
+                    let matchTID = statskeys[j].match(tidRegexp);
+                    if (matchTID == null) {
+                        console.log(`tid not found in ${statskeys[j]}.`);
+                        debugger;
+                        return;
+                    }
+                    if (bTotalCount) {
+                        tenantNode.total = Math.max(Number(statsvalues[j]), tenantNode.total);
+                        console.log(`----- ${tenantNode.name} TID: ${tenantNode.tid} batchId: ${tenantNode.batchId}`);
+                        console.log(`----- ${tenantNode.name} Total To Read: ${tenantNode.total}`);
                     }
-                    if (statskeys[j].startsWith("Writer")) { 		// store the Writer value as currentW
-                        currentW = statsvalues[j];
+                    else {
+                        tenantNode.read = Math.max(Number(statsvalues[j]), tenantNode.read);
+                        console.log(`----- ${tenantNode.name} Currently Read: ${tenantNode.read}`);
                     }
                 }
-                if (statskeys[j].endsWith("DeferredCount")) { 		// store the deferred count
-                    currentD = statsvalues[j];
+                if (statskeys[j].startsWith("Writer")) {
+                    // parse tid from Writer key
+                    let tidRegexp = /Writer\/TID:(.+)\/TotalCount/;
+                    if (bCurrentCount) tidRegexp = /Writer\/TID:(.+)\/CurrentCount/;
+                    if (bDeferredCount) tidRegexp = /Writer\/TID:(.+)\/DeferredCount/;
+                    let matchTID = statskeys[j].match(tidRegexp);
+                    if (matchTID == null) {
+                        console.log(`tid not found in ${statskeys[j]}.`);
+                        debugger;
+                        return;
+                    }
+                    // this Writer node should exist precisely under the Reader for this SignalR message
+                    let writerNode: TenantNode = tenantNode.targets.find((t: TenantNode) => t.tid === matchTID[1]);
+                    if (writerNode == null) {
+                        console.log(`Writer ${tenantNode.name} not found under Reader ${tenantNode.name}.`);
+                        debugger;
+                        return;
+                    }
+                    writerNode.batchId = matchingPair.BatchId;
+                    if (bTotalCount) {
+                        writerNode.total = Math.max(Number(statsvalues[j]), writerNode.total);
+                        console.log(`----- ${writerNode.name} TID: ${writerNode.tid} batchId: ${writerNode.batchId}`);
+                        console.log(`----- ${writerNode.name} Total To Write: ${writerNode.total}`);
+                    }
+                    else if (bCurrentCount) {
+                        writerNode.written = Math.max(Number(statsvalues[j]), writerNode.written);
+                        console.log(`----- ${writerNode.name} Total Written: ${writerNode.written}`);
+                    }
+                    else if (bDeferredCount) {
+                        writerNode.deferred = Math.max(Number(statsvalues[j]), writerNode.deferred);
+                        console.log(`----- ${writerNode.name} Total Deferred: ${writerNode.deferred}`);
+                    }
+                    else {
+                        console.log(`unknown writer type`);
+                        debugger;
+                        return;
+                    }
+                    writerNode.update(writerNode.total, writerNode.read, writerNode.written, writerNode.deferred);
                 }
-                statistics = statistics + statskeys[j] + "=" + statsvalues[j] + "<br />" 	// 
             }
-            updateProgress(total, currentR, currentW, currentD);
-            myFunction(item.TargetID, statistics);
-        });
-
-        connection.start().catch(console.error);
-
-        function myFunction(targetid, str) {
-            const table = document.getElementById("the-table");
-            let row = document.getElementById(targetid);
-            if (row) {
-                row.cells[1].innerHTML = "<code>" + str + "</ code>";
-            } else {
-                row = table.insertRow(1);
-                row.id = targetid;
-                let cell1 = row.insertCell(0);
-                let cell2 = row.insertCell(1);
-                let caption = (targetid === "00000000-0000-0000-0000-000000000000") ? "<B>Status of ServiceBus QUEUES</B>" : targetid;
-                cell1.innerHTML = "<code>" + caption + "</ code>";
-                cell2.innerHTML = "<code>" + str + "</ code>";
+            // update status based on all updates in this message
+            tenantNode.update(tenantNode.total, tenantNode.read, tenantNode.written, tenantNode.deferred);
+            // for each message, enumerate nodes to assess completion state
+            let bReadingComplete: boolean = true;
+            let bWritingComplete: boolean = true;
+            let bWritingStarted: boolean = false;
+            let readerTotal: number = 0;
+            let readerCurrent: number = 0;
+            let writerTotal: number = 0;
+            let writerCurrent: number = 0;
+            this.tenantNodes.map((sourceTenantNode: TenantNode) => {
+                sourceTenantNode.targets.map((writerNode: TenantNode) => {
+                    bWritingComplete &&= (writerNode.status == "complete" || writerNode.status == "failed");
+                    bWritingStarted ||= (writerNode.total > 0 || writerNode.status != "not started");
+                    writerTotal += Math.max(writerNode.total, sourceTenantNode.total);
+                    writerCurrent += writerNode.written;
+                });
+                bReadingComplete &&= (sourceTenantNode.status == "complete" || sourceTenantNode.status == "failed");
+                readerTotal += sourceTenantNode.total;
+                readerCurrent += sourceTenantNode.read;
+            });
+            // set linear gauge max and current values
+            setReadersTotal(readerTotal);
+            setReadersCurrent(readerCurrent);
+            setWritersTotal(Math.max(writerTotal, readerTotal));
+            setWritersCurrent(writerCurrent);
+            // because it is an important milestone, we always check if we have *just* completed reading
+            if (bReadingComplete && this.milestoneArray.milestones[0].Read == null) {
+                this.milestoneArray.read(setMilestones);
+                setConfigSyncResult("reading complete");
+                console.log(`Setting config sync result: "reading complete"`);
+                // trigger refresh delta tokens
+                setRefreshDeltaTrigger(true);
+                // change to % per second to complete in 7x as long as it took to get here
+                let readTS = Date.now();
+                let secsElapsed = (readTS - this.pb_startTS) / 1000;
+                let expectedPercentDone = 7;
+                let expectedPercentPerSecond = secsElapsed / expectedPercentDone;
+                this.pb_increment = expectedPercentPerSecond;
+                console.log(`Setting increment: ${this.pb_increment}% per second`);
             }
-        }
-
-        function updateProgress(total, currentR, currentW, currentD) {
-            updateRead(total, currentR);
-            updateWrite(total, currentW, currentD);
-        }
-
-        function updateRead(total, current) {
-            const element = document.getElementById("readBar");
-            const width = Math.round(100 * current / total);
-            element.style.width = width + '%';
-            element.innerHTML = "R=" + width + '%';
-        }
-
-        function updateWrite(total, w, d) {
-            const elementW = document.getElementById("writeBar");
-            const widthW = Math.round(100 * w / total);
-            elementW.style.width = widthW + '%';
-            elementW.innerHTML = "W=" + widthW + '%';
-
-            const elementD = document.getElementById("deferBar");
-            let width = 0;
-            let widthScaled = 0;
-            if (d > 0) {
-                width = Math.round(100 * d / total) + 1;
-                if (width < 10) {
-                    widthScaled = width * 10;
-                }
-                else if (width < 20) {
-                    widthScaled = width * 5;
-                }
-                else {
-                    widthScaled = width;
-                }
+            // with that out of the way, is writing complete?
+            if (bWritingComplete) {
+                this.milestoneArray.write(setMilestones);
+                setConfigSyncResult("sync complete");
+                console.log(`Setting config sync result: "complete"`);
+                this.pb_progress = 99;
             }
-            if (widthScaled + widthW >= 99) {
-                widthScaled = 99 - widthW;
+            // if not, has writing even started?
+            else if (bWritingStarted) {
+                setConfigSyncResult("writing in progress");
+                console.log(`Setting config sync result: "writing in progress"`);
             }
-            elementD.style.width = widthScaled + '%';
-            elementD.innerHTML = width + '%';
-            document.getElementById("deferred").innerHTML = 'Deferred:' + width + '% (' + d + ' of ' + total + ')';
-            // cycle through desired states for sources and targets
-            if (this.tenantNodes != null) {
-                this.tenantNodes.map((sourceTenantNode: TenantNode) => {
-                    if (sourceTenantNode.read == 0) sourceTenantNode.update(100, 50, 0, 0);
-                    else if (sourceTenantNode.read == 50) sourceTenantNode.update(100, 100, 0, 0);
-                    else sourceTenantNode.update(0, 0, 0, 0);
-                    if (sourceTenantNode.targets != null) {
-                        sourceTenantNode.targets.map((targetTenantNode: TenantNode) => {
-                            if (targetTenantNode.written == 0) targetTenantNode.update(100, 0, 50, 0);
-                            else if (targetTenantNode.written == 50) targetTenantNode.update(100, 0, 100, 0);
-                            else if (targetTenantNode.written == 100) targetTenantNode.update(100, 0, 99, 1);
-                            else targetTenantNode.update(0, 0, 0, 0);
-                        });
-                    }
-                });
+            // else, we must be reading (unless we already completed reading)
+            else if (this.milestoneArray.milestones[0].Read == null){
+                setConfigSyncResult("reading in progress");
+                console.log(`Setting config sync result: "reading in progress"`);
             }
         }
+        // start SignalR connection based on each batchId
+        batchIdArray.map((batchPair: Object) => {
+            const endpointUrl = `https://dev-signalrdispatcher-westus.azurewebsites.net/statsHub?statsId=${batchPair.BatchId}`;
+            console.log(`Creating SignalR Hub for TID: ${batchPair.SourceId} ${endpointUrl}`);
+            const connection: signalR.HubConnection = new signalR.HubConnectionBuilder()
+                .withUrl(endpointUrl)
+                .withAutomaticReconnect()
+                .configureLogging(signalR.LogLevel.Information)
+                .build();
+            // when you get a message, process the message
+            connection.on("newMessage", handler);
+            connection.onreconnecting(error => {
+                console.assert(connection.state === signalR.HubConnectionState.Reconnecting);
+                console.log(`Connection lost due to error "${error}". Reconnecting.`);
+            });
+            connection.onreconnected(connectionId => {
+                console.assert(connection.state === signalR.HubConnectionState.Connected);
+                console.log(`Connection reestablished. Connected with connectionId "${connectionId}".`);
+            });
+            // restart when you get a close event
+            connection.onclose(async () => {
+                console.log(`Connection closing. Attempting restart.`);
+                await connection.start();
+            });
+            // start and display any caught exceptions in the console
+            connection.start().catch(console.error);
+        });
     }
-    */
     // start a sync cycle
-    startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: Config | null | undefined): void {
+    async startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: Config | null | undefined): Promise<APIResult>
+    {
+        let result: APIResult = new APIResult();
         if (this.tenantNodes == null || this.tenantNodes.length == 0) {
             // we should not have an empty batch array for a test
             debugger;
+            result.result = false;
+            result.error = "startSync: invalid parameters";
+            result.status = 500;
+            return result;
         }
-        // start SignalR connection
-        const connection = new signalR.HubConnectionBuilder()	// SignalR initialization
-            .withUrl("https://dev-signalrdispatcher-westus.azurewebsites.net/statsHub?statsId=df9c2e0a-f6fe-43bb-a155-d51f66dffe0e", { skipNegotiation: true, transport: signalR.HttpTransportType.WebSockets } )
-            .configureLogging(signalR.LogLevel.Information)
-            .build();
-        // when you get a message, log the message
-        connection.on("newMessage", function (message) {
-            console.log(message); // log the message
-        });
-        connection.start().catch(console.error); 
         // execute post to reader endpoint
-        readerPost(instance, authorizedUser, config);
-        // refresh delta tokens for this Configuration (we read all Configurations at once)
+        result = await readerPost(instance, authorizedUser, config);
+        return result;
     }
 }
 export class TenantNode {
@@ -675,15 +984,17 @@ export class TenantNode {
     status: string;
     name: string;
     tid: string;
+    batchId: string;
     total: number;
     read: number;
     written: number;
     deferred: number;
     targets: TenantNode[];
-    constructor(tid: string, name: string) {
+    constructor(tid: string, name: string, batchId: string) {
         this.expanded = false;
         this.name = name;
         this.tid = tid;
+        this.batchId = batchId;
         this.targets = new Array<TenantNode>();
         this.update(0, 0, 0, 0);
     }
@@ -700,7 +1011,7 @@ export class TenantNode {
         else if (this.written > 0) {
             if (this.written + this.deferred < this.total) this.status = "in progress";
             else if (this.written === this.total) this.status = "complete";
-            else if (this.written + this.deferred === this.total) this.status = "failed";
+            else if (this.written + this.deferred >= this.total) this.status = "failed";
         }
     }
 }
@@ -777,7 +1088,7 @@ export function signIn(user: User, tasks: TaskArray): void {
     tenantURL += "MicrosoftIdentity/Account/Challenge";
     let url: URL = new URL(tenantURL);
     url.searchParams.append("redirectUri", window.location.origin);
-    url.searchParams.append("scope", "openid offline_access profile user.read contacts.read CrossTenantInformation.ReadBasic.All");
+    url.searchParams.append("scope", "openid offline_access Directory.AccessAsUser.All CrossTenantInformation.ReadBasic.All");
     url.searchParams.append("domainHint", "organizations");
     if (user.oid !== "1") {
         url.searchParams.append("loginHint", user.mail);
@@ -815,9 +1126,9 @@ export function signOut(user: User): void {
 export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant: Tenant, instance: IPublicClientApplication, debug: boolean): Promise<boolean> {
     if (debug) debugger;
     // do we already have a valid tenant name? if so, nothing to add
-    if (typeof tenant.name !== 'undefined' && tenant.name !== "") return false;
+    if (tenant.name != null && tenant.name !== "") return false;
     // if needed, retrieve and cache access token
-    if (typeof loggedInUser.accessToken === 'undefined' || loggedInUser.accessToken === "") {
+    if (loggedInUser.accessToken != null && loggedInUser.accessToken === "") {
         console.log(`tenantRelationshipsGetByDomain called with invalid logged in user: ${loggedInUser.name}`);
         try {
             let response: AuthenticationResult = await instance.acquireTokenByCode({ code: loggedInUser.spacode });
@@ -837,29 +1148,32 @@ export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant:
     // make tenant endpoint call
     try {
         // create tenant info endpoint
-        var tenantEndpoint = graphConfig.graphTenantByDomainEndpoint;
+        var tenantEndpoint = getGraphEndpoint(tenant.authority) + graphConfig.graphTenantByDomainPredicate;
         tenantEndpoint += "(domainName='";
         tenantEndpoint += tenant.domain;
         tenantEndpoint += "')";
         console.log("Attempting GET from /findTenantInformationByDomainName:", tenantEndpoint);
         let response = await fetch(tenantEndpoint, options);
-        let data = await response.json();
-        if (data) {
-            if (typeof data.error !== "undefined") {
-                console.log("Failed GET from /findTenantInformationByDomainName: ", data.error.message);
-                return false;
+        if (response.status == 200 && response.statusText == "OK") {
+            let data = await response.json();
+            if (data) {
+                if (data.error != null) {
+                    debugger;
+                    console.log("Failed GET from /findTenantInformationByDomainName: ", data.error.message);
+                    return false;
+                }
+                else if (data.displayName != null && data.displayName !== "") {
+                    // set domain information on passed tenant
+                    tenant.tid = data.tenantId;
+                    tenant.name = data.displayName;
+                    console.log("Successful GET from /findTenantInformationByDomainName: ", data.displayName);
+                    return true;  // success, need UX to re-render
+                }
             }
-            else if (typeof data.displayName !== undefined && data.displayName !== "") {
-                // set domain information on passed tenant
-                tenant.tid = data.tenantId;
-                tenant.name = data.displayName;
-                console.log("Successful GET from /findTenantInformationByDomainName: ", data.displayName);
-                return true;  // success, need UX to re-render
+            else {
+                console.log("Failed to GET from /findTenantInformationByTenantId: ", tenantEndpoint);
             }
         }
-        else {
-            console.log("Failed to GET from /findTenantInformationByTenantId: ", tenantEndpoint);
-        }
     }
     catch (error: any) {
         console.log("Failed to GET from /findTenantInformationByTenantId: ", error);
@@ -871,9 +1185,9 @@ export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant:
 export async function tenantRelationshipsGetById(user: User, ii: InitInfo, instance: IPublicClientApplication, tasks: TaskArray, debug: boolean): Promise<boolean> {
     if (debug) debugger;
     // do we already have a valid company name? if so, nothing to add, no need for UX to re-render
-    if (typeof user.companyName !== 'undefined' && user.companyName !== "") return false;
+    if (user.companyName != "") return false;
     // if needed, retrieve and cache access token
-    if (typeof user.accessToken === 'undefined' || user.accessToken === "") {
+    if (user.accessToken === "") {
         try {
             let response: AuthenticationResult = await instance.acquireTokenByCode({ code: user.spacode });
             user.accessToken = response.accessToken; // cache access token
@@ -892,7 +1206,7 @@ export async function tenantRelationshipsGetById(user: User, ii: InitInfo, insta
     // make tenant endpoint call
     try {
         // create tenant info endpoint
-        var tenantEndpoint = graphConfig.graphTenantByIdEndpoint;
+        var tenantEndpoint = getGraphEndpoint(user.authority) + graphConfig.graphTenantByIdPredicate;
         tenantEndpoint += "(tenantId='";
         tenantEndpoint += user.tid;
         tenantEndpoint += "')";
@@ -931,6 +1245,54 @@ export async function tenantRelationshipsGetById(user: User, ii: InitInfo, insta
     tasks.setTaskEnd("GET tenant details", new Date(), "failed");
     return false; // failed, no need for UX to re-render
 }
+//tenantUnauthenticatedLookup (from https://gettenantpartitionweb.azurewebsites.net/js/gettenantpartition.js)
+export async function tenantUnauthenticatedLookup(tenant: Tenant, debug: boolean): Promise<boolean> {
+    if (debug) debugger;
+    // do we already have a valid tenant ID? if so, nothing to add
+    if (tenant.tid !== "") return false;
+    // do we not have a valid domain? if so, nothing to lookup
+    if (tenant.domain == "") return false;
+    // prepare the 3 endpoints and corresponding regular expressions
+    let endpoints: string[] = [graphConfig.authorityWW, graphConfig.authorityUS, graphConfig.authorityCN];
+    let regexes: RegExp[] = [graphConfig.authorityWWRegex, graphConfig.authorityUSRegex, graphConfig.authorityCNRegex];
+    // make unauthenticated well-known openid endpoint call(s)
+    let response = null;
+    try {
+        for (let j = 0; j < 3; j++) {
+            // create well-known openid endpoint
+            var openidEndpoint = endpoints[j];
+            openidEndpoint += tenant.domain;
+            openidEndpoint += "/.well-known/openid-configuration";
+            console.log("Attempting GET from openid well-known endpoint: ", openidEndpoint);
+            response = await fetch(openidEndpoint);
+            if (response.status == 200 && response.statusText == "OK") {
+                let data = await response.json();
+                if (data) {
+                    // store tenant ID and authority
+                    var tenantAuthEndpoint = data.authorization_endpoint;
+                    var authMatches = tenantAuthEndpoint.match(regexes[j]);
+                    tenant.tid = authMatches[2];
+                    tenant.authority = authMatches[1];  // USGov tenants are registered in WW with USGov authority values!
+                    console.log("Successful GET from openid well-known endpoint");
+                    return true;  // success, need UX to re-render
+                }
+                else {
+                    console.log(`Failed JSON parse of openid well-known endpoint response ${openidEndpoint}.`);
+                }
+            }
+            else {
+                console.log(`Failed GET from ${openidEndpoint}.`);
+            }
+        }
+    }
+    catch (error: any) {
+        console.log("Failed to GET from openid well-known endpoint: ", error);
+    }
+    if (tenant.tid == "" || tenant.authority == "") {
+        console.log(`GET from openid well-known endpoint failed to find tenant: ${response ? response.statusText : "unknown"}`);
+    }
+    return false; // failed, no need for UX to re-render
+}
 //usersGet - GET from AAD Users endpoint
 export async function usersGet(tenant: Tenant): Promise<{ users: string[], error: string }> {
     // need a read or write access token to get graph users
@@ -1011,23 +1373,45 @@ export async function configsRefresh(instance: IPublicClientApplication, authori
 export async function initGet(instance: IPublicClientApplication, authorizedUser: User, user: User, ii: InitInfo, tasks: TaskArray, debug: boolean): Promise<APIResult> {
     let result: APIResult = new APIResult();
     if (debug) debugger;
-    // get tenant name and domain from AAD
-    result.result = await tenantRelationshipsGetById(user, ii, instance, tasks, debug);
-    // if this is the first time, we have just gotten tenant info, then we must POST user and not-yet-onboarded tenant to back end
-    if (result.result) {
-        tasks.setTaskStart("POST config init", new Date());
-        result = await initPost(instance, authorizedUser, user, debug);
-        tasks.setTaskEnd("POST config init", new Date(), result.result ? "complete" : "failed");
-    }
-    // simlarly, if we just did our first post, then query config backend for workspace(s) associated with this user
-    if (result.result) {
-        tasks.setTaskStart("GET workspaces", new Date());
-        result = await workspaceInfoGet(instance, authorizedUser, user, ii, debug);
-        tasks.setTaskEnd("GET workspaces", new Date(), result.result ? "complete" : "failed");
-    }
-    if (result.result) result.error = version;
-    else console.log("@mindline/sync package version: " + version);
-    return result;
+    // lookup authority for this user (the lookup call does it based on domain, but TID works as well to find authority)
+    let tenant: Tenant = new Tenant();
+    tenant.domain = user.tid;
+    let bResult: boolean = await tenantUnauthenticatedLookup(tenant, debug);
+    if (bResult) {
+        // success, we at least got authority as a new bit of information at this point
+        user.authority = tenant.authority;
+        // do we have a logged in user from the same authority as this newly proposed tenant?
+        let loggedInUser: User | undefined = ii.us.find((u: User) => (u.session === "Sign Out" && u.authority === user.authority));
+        if (loggedInUser != null) {
+            // get tenant name and domain from AAD
+            result.result = await tenantRelationshipsGetById(user, ii, instance, tasks, debug);
+            // if this is the first time, we have just gotten tenant info, then we must POST user and not-yet-onboarded tenant to back end
+            if (result.result) {
+                tasks.setTaskStart("POST config init", new Date());
+                result = await initPost(instance, authorizedUser, user, debug);
+                tasks.setTaskEnd("POST config init", new Date(), result.result ? "complete" : "failed");
+            }
+            // simlarly, if we just did our first post, then query config backend for workspace(s) associated with this user
+            if (result.result) {
+                tasks.setTaskStart("GET workspaces", new Date());
+                result = await workspaceInfoGet(instance, authorizedUser, user, ii, debug);
+                tasks.setTaskEnd("GET workspaces", new Date(), result.result ? "complete" : "failed");
+            }
+            if (result.result) result.error = version;
+            else console.log("@mindline/sync package version: " + version);
+            return result;
+        }
+        else {
+            result.error = `${user.mail} insufficient privileges to lookup under authority: ${user.authority}.`;
+            result.result = false;
+            return result;
+        }
+    }
+    else {
+        result.error = `Failed to retrieve authority for user "${user.mail}" TID ${user.tid}.`;
+        result.result = false;
+        return result;
+    }
 }
 export async function tenantAdd(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string): Promise<APIResult> {
     return tenantPost(instance, authorizedUser, tenant, workspaceId);
@@ -1051,7 +1435,7 @@ function processReturnedAdmins(workspace: Workspace, ii: InitInfo, returnedAdmin
     returnedAdmins.map((item) => {
         // are we already tracking this user?
         let user: User | null = null;
-        let usIndex = ii.us.findIndex((u) => u.oid === item.userId);
+        let usIndex = ii.us.findIndex((u) => (u.oid === item.userId || u.oid === item.email));
         if (usIndex === -1) {
             // start tracking
             let dummyIndex = ii.us.findIndex((u) => u.oid === "1");
@@ -1070,13 +1454,13 @@ function processReturnedAdmins(workspace: Workspace, ii: InitInfo, returnedAdmin
             user = ii.us.at(usIndex);
         }
         // refresh all the data available from the server
-        user.oid = item.userId;
+        user.oid = item.userId ? item.userId : item.email;
         user.name = item.firstName;
         user.mail = item.email;
         user.tid = item.tenantId;
         // ensure this workspace tracks this user
-        let idx = workspace.associatedUsers.findIndex((u) => u === item.userId);
-        if (idx == -1) workspace.associatedUsers.push(item.userId);
+        let idx = workspace.associatedUsers.findIndex((u) => u === user.oid);
+        if (idx == -1) workspace.associatedUsers.push(user.oid);
     });
 }
 function processReturnedTenants(workspace: Workspace, ii: InitInfo, returnedTenants: Array<Object>) {
@@ -1091,7 +1475,7 @@ function processReturnedTenants(workspace: Workspace, ii: InitInfo, returnedTena
                 // clear and overwrite dummy
                 tenant = ii.ts.at(dummyIndex);
             } else {
-                // create and track new workspace
+                // create and track new tenant
                 tenant = new Tenant();
                 ii.ts.push(tenant);
             }
@@ -1105,7 +1489,12 @@ function processReturnedTenants(workspace: Workspace, ii: InitInfo, returnedTena
         tenant.tenantType = item.type.toLowerCase(); // should now be strings
         tenant.permissionType = item.permissionType.toLowerCase(); // should now be strings
         tenant.onboarded = item.isOnboarded ? "true" : "false";
-        tenant.authority = item.authority;
+
+        // canonicalize authority when getting it from config backend
+        const regex = /^(https:\/\/login.microsoftonline.(?:us|com)\/)organizations\/v2.0$/;
+        const regexMatch = item.authority.match(regex);
+        tenant.authority = regexMatch ? regexMatch[1] : item.authority;
+
         tenant.readServicePrincipal = item.readServicePrincipal;
         tenant.writeServicePrincipal = item.writeServicePrincipal;
         // ensure this workspace tracks this tenant
@@ -1143,11 +1532,14 @@ function processReturnedConfigs(workspace: Workspace, ii: InitInfo, returnedConf
         item.tenants.map((tci) => {
             let tenantConfigInfo = new TenantConfigInfo();
             tenantConfigInfo.tid = tci.tenantId;
-            tenantConfigInfo.sourceGroupId = tci.sourceGroupId;
-            tenantConfigInfo.sourceGroupName = tci.sourceGroupName;
+            tenantConfigInfo.sourceGroupId = tci.sourceGroupId ?? "";
+            tenantConfigInfo.sourceGroupName = tci.sourceGroupName ?? "";
+            tenantConfigInfo.targetGroupId = tci.targetGroupId ?? "";
+            tenantConfigInfo.targetGroupName = tci.targetGroupName ?? "";
             tenantConfigInfo.configurationTenantType = tci.configurationTenantType.toLowerCase();
             tenantConfigInfo.deltaToken = tci.deltaToken ?? "";
             tenantConfigInfo.configId = config!.id;
+            tenantConfigInfo.batchId = tci.batchId ?? "";
             config!.tenants.push(tenantConfigInfo);
         });
         // ensure this workspace tracks this config