120 lines
3.5 KiB
JavaScript
120 lines
3.5 KiB
JavaScript
import { API } from 'api'
|
|
import { Node } from 'node'
|
|
|
|
export class Sync {
|
|
constructor() {
|
|
this.foo = ''
|
|
}
|
|
|
|
static async nodesFromServer() {//{{{
|
|
let duration = 0
|
|
const syncStart = Date.now()
|
|
try {
|
|
// The latest sync node value is used to retrieve the changes
|
|
// from the backend.
|
|
const state = await nodeStore.getAppState('latest_sync_node')
|
|
const oldMax = (state?.value ? state.value : 0)
|
|
let currMax = oldMax
|
|
|
|
let offset = 0
|
|
let res = { Continue: false }
|
|
let batch = 0
|
|
do {
|
|
batch++
|
|
res = await API.query('POST', `/sync/from_server/${oldMax}/${offset}`)
|
|
if (res.Nodes.length > 0)
|
|
console.log(`Node sync batch #${batch}`)
|
|
offset += res.Nodes.length
|
|
currMax = Math.max(currMax, res.MaxSeq)
|
|
|
|
/* Go through each node and determine if they are older than
|
|
* the node in IndexedDB. If they are, they are just history
|
|
* and can be ignored since history is currently not stored
|
|
* in the browser.
|
|
*
|
|
* If the backed node is newer, the local node is stored in
|
|
* a separate table in IndexedDB to at a later stage in the
|
|
* sync be preserved in the backend. */
|
|
|
|
let backendNode = null
|
|
for (const i in res.Nodes) {
|
|
backendNode = new Node(res.Nodes[i], -1)
|
|
await Sync.handleNode(backendNode)
|
|
}
|
|
|
|
} while (res.Continue)
|
|
|
|
nodeStore.setAppState('latest_sync_node', currMax)
|
|
} catch (e) {
|
|
console.log('sync node tree', e)
|
|
} finally {
|
|
const syncEnd = Date.now()
|
|
duration = (syncEnd - syncStart) / 1000
|
|
const count = await nodeStore.nodeCount()
|
|
console.log(`Node sync took ${duration}s`, count)
|
|
}
|
|
return duration
|
|
}//}}}
|
|
static async handleNode(backendNode) {//{{{
|
|
try {
|
|
/* Retrieving the local copy of this node from IndexedDB.
|
|
* The backend node can be discarded if it is older than
|
|
* the local copy since it is considered history preserved
|
|
* in the backend. */
|
|
return nodeStore.get(backendNode.UUID)
|
|
.then(async localNode => {
|
|
if (localNode.updated() >= backendNode.updated()) {
|
|
console.log(`History from backend: ${backendNode.UUID}`)
|
|
return
|
|
}
|
|
|
|
/* If the local node hasn't seen unsynchronized change,
|
|
* it can be replaced without anything else being done
|
|
* since it is already on the backend server.
|
|
*
|
|
* If the local node has seen change, the change is already
|
|
* placed into the send_queue anyway. */
|
|
return nodeStore.add([backendNode])
|
|
|
|
})
|
|
.catch(async () => {
|
|
// Not found in IndexedDB - OK to just insert since it only exists in backend.
|
|
return nodeStore.add([backendNode])
|
|
})
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}//}}}
|
|
|
|
static async nodesToServer() {//{{{
|
|
while(true) {
|
|
try {
|
|
// Send nodes in batches until everything is sent, or an error has occured.
|
|
const nodesToSend = await nodeStore.sendQueue.retrieve(2)
|
|
if (nodesToSend.length === 0)
|
|
break
|
|
console.debug(`Sending ${nodesToSend.length} node(s) to server`)
|
|
|
|
const request = {
|
|
NodeData: JSON.stringify(nodesToSend),
|
|
}
|
|
const res = await API.query('POST', '/sync/to_server', request)
|
|
if (!res.OK) {
|
|
// TODO - implement better error management here.
|
|
console.log(res)
|
|
alert(res)
|
|
return
|
|
}
|
|
|
|
// Nodes are archived on server and can now be deleted from the send queue.
|
|
const keys = nodesToSend.map(node => node.ClientSequence)
|
|
console.log(await nodeStore.sendQueue.delete(keys))
|
|
|
|
} catch (e) {
|
|
console.trace(e)
|
|
alert(e)
|
|
return
|
|
}
|
|
}
|
|
}//}}}
|
|
}
|