RanchiMall/localbitcoinplusplus
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed db functions promise issues

Browse Source
This commit is contained in:
Abhishek Sinha 2019-09-27 15:42:22 +05:30
parent 11bd902246
commit 6db9c84059
1 changed files with 436 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

632
supernode/index.html
View File

@ -22102,6 +22102,16 @@
] = true; ] = true;
const RM_RPC = new localbitcoinplusplus.rpc(); const RM_RPC = new localbitcoinplusplus.rpc();
// Ask backup Supernodes to delete deletable data from backup db instance
RM_RPC.send_rpc
.call(this, "delete_deletables_from_supernode_db_instance", {
trader_flo_address: su_db_data.trader_flo_address,
delete_deletables: true
})
.then(server_response => doSend(server_response));
// Inform users
RM_RPC.send_rpc RM_RPC.send_rpc
.call(this, "supernode_message", { .call(this, "supernode_message", {
trader_flo_address: trader_flo_address:
@ -22139,7 +22149,6 @@
) { ) {
(async function() { (async function() {
let _addDB = addDB; let _addDB = addDB;
let _removeAllinDB = removeAllinDB;
let _updateinDB = updateinDB; let _updateinDB = updateinDB;
let backup_db; let backup_db;
@ -22231,6 +22240,60 @@
} }
break; break;
case "delete_deletables_from_supernode_db_instance":
if(localbitcoinplusplus.master_configurations.supernodesPubKeys
.includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
&&
localbitcoinplusplus.master_configurations.supernodesPubKeys
.includes(res_obj.nodePubKey)) {
if(res_obj.params[0].delete_deletables===true
&& typeof localbitcoinplusplus.newBackupDatabase
.db[res_obj.params[0].trader_flo_address]==="object") {
const backup_db_inst = localbitcoinplusplus.newBackupDatabase
.db[res_obj.params[0].trader_flo_address];
const _readAllDB = backup_db_inst.backup_readAllDB.bind(backup_db_inst);
const _removeinDB = backup_db_inst.backup_removeinDB.bind(backup_db_inst);
const tableArray = [
"deposit",
"cash_deposits",
"withdraw_cash",
"withdraw_btc",
"cash_balances",
"crypto_balances",
"buyOrders",
"sellOrders",
"system_btc_reserves_private_keys"
];
let del_promise = [];
(async function() {
try {
for (let tbl of tableArray) {
const allDataPromises = await _readAllDB(tbl, false);
for(t of allDataPromises) {
if(t.is_deletable===true) {
console.log(tbl, t);
del_promise.push(_removeinDB(tbl, t.id, true));
}
}
}
console.log(del_promise);
await Promise.all(del_promise);
} catch (error) {
throw new Error(error);
}
})();
}
}
break;
case "reconnect_with_another_supernode": case "reconnect_with_another_supernode":
if ( if (
typeof res_obj.params == "object" && typeof res_obj.params == "object" &&
@ -25745,7 +25808,6 @@
) { ) {
(async function() { (async function() {
let _addDB = addDB; let _addDB = addDB;
let _removeAllinDB = removeAllinDB;
let _updateinDB = updateinDB; let _updateinDB = updateinDB;
let backup_db; let backup_db;
@ -26418,6 +26480,60 @@
} }
break; break;
case "delete_deletables_from_supernode_db_instance":
if(localbitcoinplusplus.master_configurations.supernodesPubKeys
.includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
&&
localbitcoinplusplus.master_configurations.supernodesPubKeys
.includes(res_obj.nodePubKey)) {
if(res_obj.params[0].delete_deletables===true
&& typeof localbitcoinplusplus.newBackupDatabase
.db[res_obj.params[0].trader_flo_address]==="object") {
const backup_db_inst = localbitcoinplusplus.newBackupDatabase
.db[res_obj.params[0].trader_flo_address];
const _readAllDB = backup_db_inst.backup_readAllDB.bind(backup_db_inst);
const _removeinDB = backup_db_inst.backup_removeinDB.bind(backup_db_inst);
const tableArray = [
"deposit",
"cash_deposits",
"withdraw_cash",
"withdraw_btc",
"cash_balances",
"crypto_balances",
"buyOrders",
"sellOrders",
"system_btc_reserves_private_keys"
];
let del_promise = [];
(async function() {
try {
for (let tbl of tableArray) {
const allDataPromises = await _readAllDB(tbl, false);
for(t of allDataPromises) {
if(t.is_deletable===true) {
console.log(tbl, t);
del_promise.push(_removeinDB(tbl, t.id, true));
}
}
}
console.log(del_promise);
await Promise.all(del_promise);
} catch (error) {
throw new Error(error);
}
})();
}
}
break;
default: default:
break; break;
@ -27060,7 +27176,7 @@
var request = objectStore.get(id); var request = objectStore.get(id);
request.onerror = function(event) { request.onerror = function(event) {
reject("Unable to retrieve data from database!"); reject(event);
}; };
request.onsuccess = function(event) { request.onsuccess = function(event) {
@ -27091,11 +27207,12 @@
var transaction = db.transaction([tablename]); var transaction = db.transaction([tablename]);
var objectStore = transaction.objectStore(tablename); var objectStore = transaction.objectStore(tablename);
let response = []; let response = [];
objectStore.openCursor().onerror = function(event) { var myIndex = objectStore.index(index);
myIndex.openCursor().onerror = function(event) {
console.error("Error fetching data"); console.error("Error fetching data");
reject(event); reject(event);
}; };
objectStore.openCursor().onsuccess = function(event) { myIndex.openCursor().onsuccess = function(event) {
let cursor = event.target.result; let cursor = event.target.result;
if (cursor) { if (cursor) {
if (cursor.value[index] == indexValue) { if (cursor.value[index] == indexValue) {
@ -27119,109 +27236,158 @@
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let response = []; let response = [];
var objectStore = db.transaction(tablename).objectStore(tablename); var objectStore = db.transaction(tablename).objectStore(tablename);
objectStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result; if ('getAll' in objectStore) {
if (cursor) { // IDBObjectStore.getAll() will return the full set of items in our store.
if (filter_deletables == true) { objectStore.getAll().onsuccess = function(event) {
if (typeof cursor.value.is_deletable == "undefined") { resolve(event.target.result);
response.push(cursor.value); };
} else {
objectStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (cursor) {
if (filter_deletables == true) {
if (typeof cursor.value.is_deletable == "undefined") {
response.push(cursor.value);
}
} else {
response.push(cursor.value);
} }
} else {
response.push(cursor.value);
}
cursor.continue(); cursor.continue();
} else { } else {
resolve(response); resolve(response);
} }
}; };
}
}); });
} }
async function addDB(tablename, dbObject) { function addDB(tablename, dbObject) {
try { return new Promise((resolve, reject) => {
if (typeof dbObject.vectorClock == "undefined") try {
dbObject.vectorClock = 0; if (typeof dbObject.vectorClock == "undefined")
if (typeof dbObject.timestamp == "undefined") dbObject.vectorClock = 0;
dbObject.timestamp = +new Date(); if (typeof dbObject.timestamp == "undefined")
let request = db.transaction([tablename], "readwrite"); dbObject.timestamp = +new Date();
let store = request.objectStore(tablename); let request = db.transaction([tablename], "readwrite")
await store.add(dbObject); .objectStore(tablename)
await request.complete; .add(dbObject);
console.info("Data added in " + tablename);
return dbObject; request.onsuccess = function (event) {
} catch (error) { console.trace("Data added in " + tablename);
return new Error(error); resolve(dbObject);
} };
request.onerror = function (event) {
reject(event);
}
} catch (error) {
reject(error);
return new Error(error);
}
});
} }
async function updateinDB( function updateinDB(
tablename, tablename,
Obj, Obj,
key, key,
updateByVectorClock = false, updateByVectorClock = false,
increaseVectorClock = true increaseVectorClock = true
) { ) {
// updateByVectorClock==true will not return Obj back. return new Promise((resolve, reject) => {
// Return value will be undefined try {
try { if (typeof Obj.vectorClock == "undefined") {
if (typeof Obj.vectorClock == "undefined") { Obj.vectorClock = 0;
Obj.vectorClock = 0; } else if (increaseVectorClock === false) {
} else if (increaseVectorClock === false) { // leave the vector clock field unchanged
// leave the vector clock field unchanged } else {
} else { Obj.vectorClock += 1;
Obj.vectorClock += 1; }
} if (typeof Obj.timestamp !== "number") {
if (typeof Obj.timestamp !== "number") { Obj.timestamp = +new Date();
Obj.timestamp = +new Date(); }
} var request = db.transaction([tablename], "readwrite")
var request = db.transaction([tablename], "readwrite"); .objectStore(tablename);
let store = request.objectStore(tablename); if (updateByVectorClock === true) {
if (updateByVectorClock === true) { if (typeof key == "undefined") {
if (typeof key == "undefined") { key = Obj[request.keyPath];
key = Obj[store.keyPath]; }
let objectStoreRequest = request.get(key);
objectStoreRequest.onsuccess = function (event) {
var myRecord = objectStoreRequest.result;
if (typeof myRecord !== "object") {
Obj.vectorClock =
typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
request = db.transaction([tablename], "readwrite")
.objectStore(tablename).put(Obj);
} else if (myRecord.vectorClock < Obj.vectorClock) {
request = db.transaction([tablename], "readwrite")
.objectStore(tablename).put(Obj);
} else {
resolve(Obj);
}
request.onsuccess = function() {
resolve(Obj);
}
request.onerror = function(e) {
reject(e);
}
};
} else {
request = db.transaction([tablename], "readwrite")
.objectStore(tablename).put(Obj);
}
request.onsuccess = function() {
resolve(Obj);
}
request.onerror = function(e) {
reject(e);
}
} catch (error) {
reject(error);
return new Error(error);
} }
let objectStoreRequest = store.get(key); });
objectStoreRequest.onsuccess = async function(event) {
var myRecord = objectStoreRequest.result;
if (typeof myRecord !== "object") {
Obj.vectorClock =
typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
await store.put(Obj);
await request.complete;
} else if (myRecord.vectorClock < Obj.vectorClock) {
await store.put(Obj);
await request.complete;
}
};
} else {
await store.put(Obj);
await request.complete;
}
return Obj;
} catch (error) {
return new Error(error);
}
} }
async function removeinDB(tablename, id) { function removeinDB(tablename, id) {
try { return new Promise((resolve, reject) => {
var request = db.transaction([tablename], "readwrite"); try {
let store = request.objectStore(tablename); var request = db.transaction([tablename], "readwrite")
await store.delete(id); .objectStore(tablename)
await request.complete; .delete(id);
return id;
} catch (error) { request.onsuccess = function(event) {
return new Error(error); resolve(id);
} }
request.onerror = function(event) {
reject(event);
}
} catch (error) {
reject(error);
return new Error(error);
}
});
} }
function removeByIndex(tablename, indexName, indexValue) { function removeByIndex(tablename, indexName, indexValue) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
var request = db var db_request = db
.transaction([tablename], "readwrite") .transaction([tablename], "readwrite")
.objectStore(tablename); .objectStore(tablename);
var index = request.index(indexName); var index = db_request.index(indexName);
var request = index.openCursor(IDBKeyRange.only(indexValue)); var request = index.openCursor(IDBKeyRange.only(indexValue));
request.onsuccess = function() { request.onsuccess = function() {
var cursor = request.result; var cursor = request.result;
@ -27238,20 +27404,27 @@
}); });
} }
async function removeAllinDB(tablename) { function removeAllinDB(tablename) {
try { return new Promise((resolve, reject) => {
var request = db.transaction([tablename], "readwrite"); try {
var objectStore = request.objectStore(tablename); var request = db.transaction([tablename], "readwrite");
var objectStoreRequest = await objectStore.clear(); var objectStore = request.objectStore(tablename);
await request.complete; var objectStoreRequest = objectStore.clear();
console.info( objectStoreRequest.onsuccess = function(event) {
"All the data entry has been removed from your database " + console.info(
tablename "All the data entry has been removed from your database " +
); tablename
return tablename; );
} catch (error) { resolve(tablename);
return new Error(error); };
} objectStoreRequest.onerror = function(event) {
reject(event);
}
} catch (error) {
reject(event);
return new Error(error);
}
});
} }
</script> </script>
@ -27587,7 +27760,7 @@
let parent_request = this.request; let parent_request = this.request;
this.request.onerror = function(event) { this.request.onerror = function(event) {
reject("Unable to retrieve data from database!"); reject(event);
}; };
this.request.onsuccess = function(event) { this.request.onsuccess = function(event) {
@ -27620,11 +27793,12 @@
this.transaction = this.db.transaction([tablename]); this.transaction = this.db.transaction([tablename]);
var objectStore = this.transaction.objectStore(tablename); var objectStore = this.transaction.objectStore(tablename);
let response = []; let response = [];
objectStore.openCursor().onerror = function(event) { var myIndex = objectStore.index(index);
myIndex.openCursor().onerror = function(event) {
console.error("Error fetching data"); console.error("Error fetching data");
reject(event); reject(event);
}; };
objectStore.openCursor().onsuccess = function(event) { myIndex.openCursor().onsuccess = function(event) {
let cursor = event.target.result; let cursor = event.target.result;
if (cursor) { if (cursor) {
if (cursor.value[index] == indexValue) { if (cursor.value[index] == indexValue) {
@ -27650,6 +27824,7 @@
var objectStore = this.db var objectStore = this.db
.transaction(tablename) .transaction(tablename)
.objectStore(tablename); .objectStore(tablename);
objectStore.openCursor().onsuccess = function(event) { objectStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result; let cursor = event.target.result;
if (cursor) { if (cursor) {
@ -27665,123 +27840,165 @@
} else { } else {
resolve(response); resolve(response);
} }
}; };
}); });
}, },
async backup_addDB(tablename, dbObject) { backup_addDB(tablename, dbObject) {
try { return new Promise((resolve, reject) => {
if (typeof dbObject.vectorClock == "undefined") try {
dbObject.vectorClock = 0;
if (typeof dbObject.timestamp == "undefined") if (typeof dbObject.vectorClock == "undefined")
dbObject.timestamp = +new Date(); dbObject.vectorClock = 0;
this.request = this.db.transaction([tablename], "readwrite");
let store = this.request.objectStore(tablename); if (typeof dbObject.timestamp == "undefined")
await store.add(dbObject); dbObject.timestamp = +new Date();
await this.request.complete;
console.info("Data added in " + tablename); this.request = this.db.transaction([tablename], "readwrite")
return dbObject; .objectStore(tablename)
} catch (error) { .add(dbObject);
return new Error(error);
} this.request.onsuccess = function (event) {
console.trace("Data added in " + tablename);
resolve(dbObject);
};
this.request.onerror = function (event) {
reject(event);
}
} catch (error) {
reject(error);
return new Error(error);
}
});
}, },
async backup_updateinDB( backup_updateinDB(
tablename, tablename,
Obj, Obj,
key, key,
updateByVectorClock = false, updateByVectorClock = false,
increaseVectorClock = true increaseVectorClock = true
) { ) {
try { return new Promise((resolve, reject) => {
if (typeof Obj.vectorClock == "undefined") { try {
Obj.vectorClock = 0; if (typeof Obj.vectorClock == "undefined") {
} else if (increaseVectorClock === false) { Obj.vectorClock = 0;
// leave the vector clock field unchanged } else if (increaseVectorClock === false) {
} else { // leave the vector clock field unchanged
Obj.vectorClock += 1; } else {
} Obj.vectorClock += 1;
if (typeof Obj.timestamp !== "number") { }
Obj.timestamp = +new Date(); if (typeof Obj.timestamp !== "number") {
} Obj.timestamp = +new Date();
let that = this; }
this.request = this.db.transaction([tablename], "readwrite"); this.request = this.db.transaction([tablename], "readwrite")
let store = this.request.objectStore(tablename); .objectStore(tablename);
if (updateByVectorClock === true) { if (updateByVectorClock === true) {
if (typeof key == "undefined") { if (typeof key == "undefined") {
key = Obj[store.keyPath]; key = Obj[this.request.keyPath];
} }
let objectStoreRequest = store.get(key); let objectStoreRequest = this.request.get(key);
objectStoreRequest.onsuccess = function(event) { objectStoreRequest.onsuccess = function(event) {
return new Promise(async (resolve, reject) => { var myRecord = objectStoreRequest.result;
var myRecord = objectStoreRequest.result; if (typeof myRecord !== "object") {
var myRecord = objectStoreRequest.result; Obj.vectorClock =
if (typeof myRecord !== "object") { typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
Obj.vectorClock = this.request = this.db.transaction([tablename], "readwrite")
typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0; .objectStore(tablename).put(Obj);
await store.put(Obj); } else if (myRecord.vectorClock < Obj.vectorClock) {
await that.request.complete; this.request = this.db.transaction([tablename], "readwrite")
} else if (myRecord.vectorClock < Obj.vectorClock) { .objectStore(tablename).put(Obj);
await store.put(Obj); } else {
await that.request.complete; resolve(Obj);
} }
}); this.request.onsuccess = function() {
resolve(Obj); resolve(Obj);
return; }
};
} else { this.request.onerror = function(e) {
await store.put(Obj); reject(e);
await that.request.complete; }
return Obj; }.bind(this);
} else {
this.request = this.db.transaction([tablename], "readwrite")
.objectStore(tablename).put(Obj);
}
this.request.onsuccess = function() {
resolve(Obj);
}
this.request.onerror = function(e) {
reject(e);
}
} catch (error) {
reject(error);
return new Error(error);
} }
} catch (error) { });
return new Error(error);
}
}, },
async backup_removeinDB(tablename, id) { backup_removeinDB(tablename, id, remove_deletables=false) {
try { return new Promise((resolve, reject) => {
this.request = this.db.transaction([tablename], "readwrite"); try {
this.request = this.db.transaction([tablename], "readwrite");
let store = this.request.objectStore(tablename); if (remove_deletables===true) {
let objectStoreRequest = store.get(id); this.objectStore = this.request.objectStore(tablename);
let that = this;
objectStoreRequest.onsuccess = function(event) {
return new Promise(async (resolve, reject) => {
var myRecord = objectStoreRequest.result;
if (typeof myRecord == "object") { this.objectStoreRequest = this.objectStore.delete(id);
myRecord.vectorClock += 1;
// https://stackoverflow.com/a/39333479/5348972 this.objectStoreRequest.onsuccess = function(event) {
const modifiedRecord = (({ id, timestamp, vectorClock }) => ({ resolve(id);
id, }
timestamp,
vectorClock this.objectStoreRequest.onerror = function(event) {
}))(myRecord); reject(event);
}
} else {
let objectStoreRequest = this.request.objectStore(tablename).get(id);
objectStoreRequest.onsuccess = function(event) {
var myRecord = objectStoreRequest.result;
modifiedRecord.is_deletable = true; if (typeof myRecord == "object") {
myRecord.vectorClock += 1;
await store.put(modifiedRecord); // https://stackoverflow.com/a/39333479/5348972
await that.request.complete; const modifiedRecord = (({ id, timestamp, vectorClock }) => ({
return id; id,
timestamp,
vectorClock
}))(myRecord);
modifiedRecord.is_deletable = true;
this.request.objectStore(tablename).put(modifiedRecord);
return resolve(id);
}
reject(false);
}.bind(this);
objectStoreRequest.onerror = function(event) {
reject(event);
}
} }
});
reject(false); } catch (error) {
}; reject(error);
} catch (error) { return new Error(error);
return new Error(error); }
} });
}, },
backup_removeByIndex(tablename, indexName, indexValue) { backup_removeByIndex(tablename, indexName, indexValue) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
this.request = this.db this.db_request = this.db
.transaction([tablename], "readwrite") .transaction([tablename], "readwrite")
.objectStore(tablename); .objectStore(tablename);
var index = this.request.index(indexName); var index = this.db_request.index(indexName);
let parent_request = this.request; let parent_request = this.db_request;
this.request = index.openCursor(IDBKeyRange.only(indexValue)); this.request = index.openCursor(IDBKeyRange.only(indexValue));
this.request.onsuccess = async function(event) { this.request.onsuccess = async function(event) {
var cursor = event.target.result; var cursor = event.target.result;
@ -27798,19 +28015,42 @@
modifiedRecord.is_deletable = true; modifiedRecord.is_deletable = true;
await parent_request.put(modifiedRecord); parent_request.put(modifiedRecord);
await parent_request.complete;
cursor.continue(); cursor.continue();
} else { } else {
resolve(true); resolve(true);
} }
}; };
request.onerror = function(e) { this.request.onerror = function(e) {
reject(e); reject(e);
}; };
}); });
} }
}; };
function backup_removeAllinDB(tablename="") {
return new Promise((resolve, reject) => {
try {
this.request = this.db.transaction([tablename], "readwrite");
var objectStore = this.request.objectStore(tablename);
var objectStoreRequest = objectStore.clear();
objectStoreRequest.onsuccess = function(event) {
console.info(
"All the data entry has been removed from backup database " +
tablename
);
resolve(tablename);
};
objectStoreRequest.onerror = function(event) {
reject(event);
}
} catch (error) {
reject(event);
return new Error(error);
}
});
}
</script> </script>
<!-- Initialization of objects --> <!-- Initialization of objects -->