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

bug fix

Browse Source 
- Adding semicolons to end of statements to prevent potential bugs.
- Logged in ID and Database connection will be notified.
- Fixed: database.js - few functions not having return promise statement.
This commit is contained in:
sairajzero 2021-07-23 03:06:00 +05:30
parent 02d6bd0ca3
commit dea8835245
13 changed files with 571 additions and 580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gen-param.html
View File

@ -35,22 +35,22 @@
length: history.length
},
location: location.toString()
}
};
for (var i = 0; i < navigator.plugins.length; i++)
param.navigator.plugins[i] = {
name: navigator.plugins[i].name,
filename: navigator.plugins[i].filename,
description: navigator.plugins[i].description,
version: navigator.plugins[i].version
}
for (var i = 0; i < navigator.mimeTypes.length; i++) {
};
for (var i = 0; i < navigator.mimeTypes.length; i++)
param.navigator.mimeTypes[i] = {
description: navigator.mimeTypes[i].description,
type: navigator.mimeTypes[i].type,
suffixes: navigator.mimeTypes[i].suffixes
}
}
console.log(param)
};
console.log(param);
//Download the file
status.innerHTML += "<br/>Downloading file...";
status.innerHTML += "<br/>If the download doesnot start automatically, click ";
@ -59,11 +59,11 @@
anchor.href = window.URL.createObjectURL(new Blob([JSON.stringify(param)], {
type: "octet/stream"
}));
anchor.innerHTML = "here"
anchor.innerHTML = "here";
anchor.download = fileName;
status.appendChild(anchor);
anchor.click();
status.innerHTML += "<br/><b>Note: Save <i>param.json</i> file in SuperNodeStorage directory</b>"
status.innerHTML += "<br/><b>Note: Save <i>param.json</i> file in SuperNodeStorage directory</b>";
})("param.json");
</script>
</body>

2
launch.js
View File

@ -1,2 +1,2 @@
const start = require('./src/main')
const start = require('./src/main');
start();

2
post-install.js
View File

@ -8,4 +8,4 @@ To complete the setup:
To start the node, Run:
npm start
`;
console.log(message)
console.log(message);

81
src/client.js
View File

@ -5,9 +5,9 @@ function processIncomingData(data) {
try {
data = JSON.parse(data);
} catch (error) {
return reject("Data not in JSON-Format")
}
let curTime = Date.now()
return reject("Data not in JSON-Format");
};
let curTime = Date.now();
if (!data.time || data.time > curTime + floGlobals.sn_config.delayDelta ||
data.time < curTime - floGlobals.sn_config.delayDelta)
return reject("Invalid Time");
@ -26,28 +26,28 @@ function processIncomingData(data) {
return processDeleteFromUser(gid, uid, data);
*/
else
return reject("Invalid Data-format")
return reject("Invalid Data-format");
process.then(result => resolve(result))
.catch(error => reject(error))
}
})
}
.catch(error => reject(error));
};
});
};
function processDataFromUser(data) {
return new Promise((resolve, reject) => {
if (!floCrypto.validateAddr(data.receiverID))
return reject("Invalid receiverID")
let closeNode = kBucket.closestNode(data.receiverID)
return reject("Invalid receiverID");
let closeNode = kBucket.closestNode(data.receiverID);
if (!_list.serving.includes(closeNode))
return reject("Incorrect Supernode")
return reject("Incorrect Supernode");
if (!floCrypto.validateAddr(data.receiverID))
return reject("Invalid senderID")
return reject("Invalid senderID");
if (data.senderID !== floCrypto.getFloID(data.pubKey))
return reject("Invalid pubKey")
return reject("Invalid pubKey");
let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
.map(d => data[d]).join("|")
.map(d => data[d]).join("|");
if (!floCrypto.verifySign(hashcontent, data.sign, data.pubKey))
return reject("Invalid signature")
return reject("Invalid signature");
DB.addData(closeNode, {
vectorClock: `${Date.now()}_${data.senderID}`,
@ -61,47 +61,46 @@ function processDataFromUser(data) {
sign: data.sign,
pubKey: data.pubKey
}).then(result => resolve([result, 'DATA']))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
function processRequestFromUser(request) {
return new Promise((resolve, reject) => {
if (!floCrypto.validateAddr(request.receiverID))
return reject("Invalid receiverID");
let closeNode = kBucket.closestNode(request.receiverID)
let closeNode = kBucket.closestNode(request.receiverID);
if (!_list.serving.includes(closeNode))
return reject("Incorrect Supernode");
DB.searchData(closeNode, request)
.then(result => resolve([result]))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
function processTagFromUser(data) {
return new Promise((resolve, reject) => {
if (!floCrypto.validateAddr(data.receiverID))
return reject("Invalid receiverID")
return reject("Invalid receiverID");
if (!(data.application in floGlobals.appList))
return reject("Invalid application")
return reject("Invalid application");
if (!floCrypto.validateAddr(data.requestorID) ||
!floGlobals.appSubAdmins.includes(data.requestorID))
return reject("Invalid requestorID")
return reject("Invalid requestorID");
if (data.requestorID !== floCrypto.getFloID(data.pubKey))
return reject("Invalid pubKey")
let closeNode = kBucket.closestNode(data.receiverID)
return reject("Invalid pubKey");
let closeNode = kBucket.closestNode(data.receiverID);
if (!_list.serving.includes(closeNode))
return reject("Incorrect Supernode")
let hashcontent = ["time", "application", "tag"]
.map(d => data[d]).join("|");
return reject("Incorrect Supernode");
let hashcontent = ["time", "application", "tag"].map(d => data[d]).join("|");
if (!floCrypto.verifySign(hashcontent, data.sign, data.pubKey))
return reject("Invalid signature");
let tag = [null, undefined, ""].includes(data.tag) ? null : [data.tag].toString();
let tag = ([null, undefined, ""].includes(data.tag) ? null : [data.tag].toString());
DB.tagData(closeNode, data.vectorClock, tag, data.time, data.pubKey, data.sign)
.then(result => resolve([result, 'TAG']))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
function checkIfRequestSatisfy(request, data) {
if (!request || request.mostRecent || request.receiverID !== data.receiverID)
@ -123,18 +122,18 @@ function checkIfRequestSatisfy(request, data) {
return false;
else if (request.senderID !== data.senderID)
return false;
}
};
return true;
}
};
module.exports = {
checkIfRequestSatisfy,
processRequestFromUser,
processIncomingData,
set DB(db){
DB = db
set DB(db) {
DB = db;
},
set _list(list){
_list = list
set _list(list) {
_list = list;
}
}
};

226
src/database.js
View File

@ -24,7 +24,7 @@ const Base_Tables = {
SUB_ADMINS: "VARCHAR(MAX)",
PRIMARY: "KEY (APP_NAME)"
}
}
};
const H_struct = {
VECTOR_CLOCK: "vectorClock",
@ -34,44 +34,44 @@ const H_struct = {
APPLICATION: "application",
TIME: "time",
PUB_KEY: "pubKey"
}
};
const B_struct = {
MESSAGE: "message",
SIGNATURE: "sign",
COMMENT: "comment"
}
};
const L_struct = {
STATUS: "status_n",
LOG_TIME: "log_time"
}
};
const T_struct = {
TAG: "tag",
TAG_TIME: "tag_time",
TAG_KEY: "tag_key",
TAG_SIGN: "tag_sign"
}
};
function Database(user, password, dbname, host = 'localhost') {
const db = {};
db.query = (s, v) => new Promise((res, rej) => {
const fn = (e, r) => e ? rej(e) : res(r)
v ? db.conn.query(s, v, fn) : db.conn.query(s, fn)
const fn = ((e, r) => e ? rej(e) : res(r));
v ? db.conn.query(s, v, fn) : db.conn.query(s, fn);
});
db.createBase = function() {
return new Promise((resolve, reject) => {
let statements = []
let statements = [];
for (let t in Base_Tables)
statements.push("CREATE TABLE IF NOT EXISTS " + t + "( " +
Object.keys(Base_Tables[t]).map(a => a + " " + Base_Tables[t][a]).join(", ") + " )");
Promise.all(statements.forEach(s => db.query(s)))
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.setLastTx = function(id, n) {
return new Promise((resolve, reject) => {
@ -79,9 +79,9 @@ function Database(user, password, dbname, host = 'localhost') {
" ON DUPLICATE KEY UPDATE N=?";
db.query(statement, [id, n, n])
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.setConfig = function(name, value) {
return new Promise((resolve, reject) => {
@ -89,69 +89,79 @@ function Database(user, password, dbname, host = 'localhost') {
" ON DUPLICATE KEY UPDATE VAL=?";
db.query(statement, [name, value, value])
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.addSuperNode = function(id, pubKey, uri) {
let statement = "INSERT INTO SuperNodes (FLO_ID, PUB_KEY, URI) VALUES (?, ?, ?)" +
" ON DUPLICATE KEY UPDATE URI=?";
db.query(statement, [id, pubKey, uri, uri])
.then(result => resolve(result))
.catch(error => reject(error))
}
return new Promise((resolve, reject) => {
let statement = "INSERT INTO SuperNodes (FLO_ID, PUB_KEY, URI) VALUES (?, ?, ?)" +
" ON DUPLICATE KEY UPDATE URI=?";
db.query(statement, [id, pubKey, uri, uri])
.then(result => resolve(result))
.catch(error => reject(error));
});
};
db.rmSuperNode = function(id) {
let statement = "DELETE FROM SuperNodes" +
" WHERE FLO_ID=?";
db.query(statement, id)
.then(result => resolve(result))
.catch(error => reject(error))
}
return new Promise((resolve, reject) => {
let statement = "DELETE FROM SuperNodes" +
" WHERE FLO_ID=?";
db.query(statement, id)
.then(result => resolve(result))
.catch(error => reject(error));
});
};
db.setSubAdmin = function(appName, subAdmins) {
let statement = "UPDATE Applications" +
" SET SUB_ADMINS=?" +
" WHERE APP_NAME=?";
db.query(statement, [subAdmins.join(","), appName])
.then(result => resolve(result))
.catch(error => reject(error))
}
return new Promise((resolve, reject) => {
let statement = "UPDATE Applications" +
" SET SUB_ADMINS=?" +
" WHERE APP_NAME=?";
db.query(statement, [subAdmins.join(","), appName])
.then(result => resolve(result))
.catch(error => reject(error));
});
};
db.addApp = function(appName, adminID) {
let statement = "INSERT INTO Applications (APP_NAME, ADMIN_ID) VALUES (?, ?)" +
" ON DUPLICATE KEY UPDATE ADMIN_ID=?";
db.query(statement, [appName, adminID, adminID])
.then(result => resolve(result))
.catch(error => reject(error))
}
return new Promise((resolve, reject) => {
let statement = "INSERT INTO Applications (APP_NAME, ADMIN_ID) VALUES (?, ?)" +
" ON DUPLICATE KEY UPDATE ADMIN_ID=?";
db.query(statement, [appName, adminID, adminID])
.then(result => resolve(result))
.catch(error => reject(error));
});
};
db.rmApp = function(appName) {
let statement = "DELETE FROM Applications" +
" WHERE APP_NAME=" + appName;
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
}
return new Promise((resolve, reject) => {
let statement = "DELETE FROM Applications" +
" WHERE APP_NAME=" + appName;
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error));
});
};
db.getBase = function() {
return new Promise((resolve, reject) => {
let tables = Object.keys(Base_Tables);
Promise.all(tables.forEach(t => db.query("SELECT * FROM " + t))).then(result => {
let tmp = Object.fromEntries(tables.map((t, i) => [t, result[i]]))
let tmp = Object.fromEntries(tables.map((t, i) => [t, result[i]]));
result = {};
result.lastTx = Object.fromEntries(tmp.LastTxs.map(a => [a.ID, a.N]));
result.sn_config = Object.fromEntries(tmp.Configs.map(a => [a.NAME, a.VAL]));
result.appList = Object.fromEntries(tmp.Applications.map(a => [a.APP_NAME, a.ADMIN_ID]));
result.appSubAdmins = Object.fromEntries(tmp.Applications.map(a => [a.APP_NAME, a.SUB_ADMINS.split(",")]))
result.appSubAdmins = Object.fromEntries(tmp.Applications.map(a => [a.APP_NAME, a.SUB_ADMINS.split(",")]));
result.supernodes = Object.fromEntries(tmp.SuperNodes.map(a.FLO_ID, {
pubKey: a.PUB_KEY,
uri: a.URI
}))
resolve(result)
}).catch(error => reject(error))
})
}
}));
resolve(result);
}).catch(error => reject(error));
});
};
db.createTable = function(snID) {
return new Promise((resolve, reject) => {
@ -176,18 +186,18 @@ function Database(user, password, dbname, host = 'localhost') {
" )";
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.dropTable = function(snID) {
return new Promise((resolve, reject) => {
let statement = "DROP TABLE _" + snID;
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.addData = function(snID, data) {
return new Promise((resolve, reject) => {
@ -196,14 +206,12 @@ function Database(user, password, dbname, host = 'localhost') {
let statement = "INSERT INTO _" + snID +
" (" + attr.join(", ") + ", " + L_struct.STATUS + ", " + L_struct.LOG_TIME + ") " +
"VALUES (" + attr.map(a => '?').join(", ") + ", 1, " + Date.now() + ")";
data = Object.fromEntries(attr.map((a, i) => [
[a, values[i]]
]));
data = Object.fromEntries(attr.map((a, i) => [a, values[i]]));
db.query(statement, values)
.then(result => resolve(data))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.tagData = function(snID, vectorClock, tag, tagTime, tagKey, tagSign) {
return new Promise((resolve, reject) => {
@ -213,7 +221,7 @@ function Database(user, password, dbname, host = 'localhost') {
[T_struct.TAG_KEY]: tagKey,
[T_struct.TAG_SIGN]: tagSign,
[L_struct.LOG_TIME]: Date.now()
}
};
let attr = Object.keys(data);
let values = attr.map(a => data[a]).concat(vectorClock);
data[H_struct.VECTOR_CLOCK] = vectorClock; //also add vectorClock to resolve data
@ -222,9 +230,9 @@ function Database(user, password, dbname, host = 'localhost') {
" WHERE " + H_struct.VECTOR_CLOCK + "=?";
db.query(statement, values)
.then(result => resolve(data))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.searchData = function(snID, request) {
return new Promise((resolve, reject) => {
@ -233,54 +241,54 @@ function Database(user, password, dbname, host = 'localhost') {
if (request.lowerVectorClock && request.upperVectorClock)
conditionArr.push(`${H_struct.VECTOR_CLOCK} BETWEEN '${request.lowerVectorClock}' AND '${request.upperVectorClock}'`);
else if (request.atKey)
conditionArr.push(`${H_struct.VECTOR_CLOCK} = '${request.atKey}'`)
conditionArr.push(`${H_struct.VECTOR_CLOCK} = '${request.atKey}'`);
else if (request.lowerVectorClock)
conditionArr.push(`${H_struct.VECTOR_CLOCK} >= '${request.lowerVectorClock}'`)
conditionArr.push(`${H_struct.VECTOR_CLOCK} >= '${request.lowerVectorClock}'`);
else if (request.upperVectorClock)
conditionArr.push(`${H_struct.VECTOR_CLOCK} <= '${request.upperVectorClock}'`)
conditionArr.push(`${H_struct.VECTOR_CLOCK} <= '${request.upperVectorClock}'`);
}
conditionArr.push(`${H_struct.APPLICATION} = '${request.application}'`);
conditionArr.push(`${H_struct.RECEIVER_ID} = '${request.receiverID}'`)
if (request.comment)
conditionArr.push(`${B_struct.COMMENT} = '${request.comment}'`)
conditionArr.push(`${B_struct.COMMENT} = '${request.comment}'`);
if (request.type)
conditionArr.push(`${H_struct.TYPE} = '${request.type}'`)
conditionArr.push(`${H_struct.TYPE} = '${request.type}'`);
if (request.senderID) {
if (Array.isArray(request.senderID))
conditionArr.push(`${H_struct.SENDER_ID} IN ('${request.senderID.join("', '")}')`);
else
conditionArr.push(`${H_struct.SENDER_ID} = '${request.senderID}'`)
}
conditionArr.push(`${H_struct.SENDER_ID} = '${request.senderID}'`);
};
//console.log(conditionArr);
let attr = Object.keys(H_struct).concat(Object.keys(B_struct))
let attr = Object.keys(H_struct).concat(Object.keys(B_struct));
let statement = "SELECT (" + attr.join(", ") + ")" +
" FROM _" + snID +
" WHERE " + conditionArr.join(" AND ") +
request.mostRecent ? "LIMIT 1" : (" ORDER BY " + H_struct.VECTOR_CLOCK);
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.lastLogTime = function(snID) {
return new Promise((resolve, reject) => {
let statement = "SELECT MAX(" + L_struct.LOG_TIME + ") FROM _" + snID;
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.createGetLastLog = function(snID) {
return new Promise((resolve, reject) => {
db.createTable(snID).then(result => {
db.lastLogTime(snID)
.then(result => resolve(result))
.catch(error => reject(error))
}).catch(error => reject(error))
})
}
.catch(error => reject(error));
}).catch(error => reject(error));
});
};
db.getData = function(snID, logtime) {
return new Promise((resolve, reject) => {
@ -289,13 +297,13 @@ function Database(user, password, dbname, host = 'localhost') {
" ORDER BY " + L_struct.LOG_TIME;
db.query(statement)
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.storeData = function(snID, data) {
return new Promise((resolve, reject) => {
let u_attr = Object.keys(B_struct).map(a => B_struct[a])
let u_attr = Object.keys(B_struct).map(a => B_struct[a]);
let attr = Object.keys(H_struct).map(a => H_struct[a]).concat(u_attr);
let values = attr.map(a => data[a]);
let u_values = u_attr.map(a => data[a]);
@ -305,9 +313,9 @@ function Database(user, password, dbname, host = 'localhost') {
"ON DUPLICATE KEY UPDATE " + u_attr.map(a => a + "=?").join(", ");
db.query(statement, values.concat(u_values))
.then(result => resolve(data))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.storeTag = function(snID, data) {
return new Promise((resolve, reject) => {
@ -318,9 +326,9 @@ function Database(user, password, dbname, host = 'localhost') {
" WHERE " + H_struct.VECTOR_CLOCK + "=" + data[H_struct.VECTOR_CLOCK];
db.query(statement, values)
.then(result => resolve(data))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.clearAuthorisedAppData = function(snID, app, adminID, subAdmins, timestamp) {
return new Promise((resolve, reject) => {
@ -332,9 +340,9 @@ function Database(user, password, dbname, host = 'localhost') {
H_struct.SENDER_ID + " NOT IN (" + subAdmins.map(a => "?").join(", ") + ") )";
db.query(statement, [timestamp, app].concat(subAdmins).push(adminID))
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.clearUnauthorisedAppData = function(snID, appList, timestamp) {
return new Promise((resolve, reject) => {
@ -343,13 +351,13 @@ function Database(user, password, dbname, host = 'localhost') {
H_struct.APPLICATION + " NOT IN (" + appList.map(a => "?").join(", ") + ")";
db.query(statement, [timestamp].concat(appList))
.then(result => resolve(result))
.catch(error => reject(error))
})
}
.catch(error => reject(error));
});
};
db.close = function() {
db.conn.end();
}
};
return new Promise((resolve, reject) => {
let conn = mysql.createConnection({
@ -361,9 +369,9 @@ function Database(user, password, dbname, host = 'localhost') {
conn.connect((err) => {
if (err) return reject(err);
db.conn = conn;
resolve(db)
resolve(db);
});
})
}
});
};
module.exports = Database;

178
src/floBlockchainAPI.js
View File

@ -9,16 +9,16 @@
fetch_retry: function(apicall) {
return new Promise((resolve, reject) => {
this.serverList.splice(this.curPos, 1);
this.curPos = floCrypto.randInt(0, this.serverList.length - 1)
this.curPos = floCrypto.randInt(0, this.serverList.length - 1);
this.fetch_api(apicall)
.then(result => resolve(result))
.catch(error => reject(error));
})
});
},
fetch_api: function(apicall) {
return new Promise((resolve, reject) => {
if (this.serverList.length === 0)
reject("No floSight server working")
reject("No floSight server working");
else {
fetch(this.serverList[this.curPos] + apicall).then(response => {
if (response.ok)
@ -27,21 +27,21 @@
this.fetch_retry(apicall)
.then(result => resolve(result))
.catch(error => reject(error));
}
};
}).catch(error => {
this.fetch_retry(apicall)
.then(result => resolve(result))
.catch(error => reject(error));
})
}
})
});
};
});
}
},
//Promised function to get data from API
promisedAPI: function(apicall) {
return new Promise((resolve, reject) => {
console.log(apicall)
console.log(apicall);
this.util.fetch_api(apicall)
.then(result => resolve(result))
.catch(error => reject(error));
@ -64,7 +64,7 @@
data = JSON.stringify(data);
this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data)
.then(txid => resolve(txid))
.catch(error => reject(error))
.catch(error => reject(error));
});
},
@ -75,7 +75,7 @@
reject(`Invalid address : ${senderAddr}`);
else if (!floCrypto.validateAddr(receiverAddr))
reject(`Invalid address : ${receiverAddr}`);
if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
reject("Invalid Private key!");
else if (typeof sendAmt !== 'number' || sendAmt <= 0)
reject(`Invalid sendAmt : ${sendAmt}`);
@ -84,14 +84,12 @@
var utxoAmt = 0.0;
var fee = floGlobals.fee;
this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
for (var i = utxos.length - 1;
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
for (var i = utxos.length - 1; (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
if (utxos[i].confirmations) {
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
.scriptPubKey)
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
utxoAmt += utxos[i].amount;
} else break;
}
};
if (utxoAmt < sendAmt + fee)
reject("Insufficient balance!");
else {
@ -103,10 +101,10 @@
var signedTxHash = trx.sign(privKey, 1);
this.broadcastTx(signedTxHash)
.then(txid => resolve(txid))
.catch(error => reject(error))
}
}).catch(error => reject(error))
}
.catch(error => reject(error));
};
}).catch(error => reject(error));
};
});
},
@ -116,27 +114,25 @@
if (!floCrypto.validateAddr(floID))
return reject(`Invalid floID`);
if (!floCrypto.verifyPrivKey(privKey, floID))
return reject("Invalid Private Key")
return reject("Invalid Private Key");
var trx = bitjs.transaction();
var utxoAmt = 0.0;
var fee = floGlobals.fee;
this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
for (var i = utxos.length - 1; i >= 0; i--) {
for (var i = utxos.length - 1; i >= 0; i--)
if (utxos[i].confirmations) {
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
.scriptPubKey)
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
utxoAmt += utxos[i].amount;
}
}
};
trx.addoutput(floID, utxoAmt - fee);
trx.addflodata(floData.replace(/\n/g, ' '));
var signedTxHash = trx.sign(privKey, 1);
this.broadcastTx(signedTxHash)
.then(txid => resolve(txid))
.catch(error => reject(error))
}).catch(error => reject(error))
})
.catch(error => reject(error));
}).catch(error => reject(error));
});
},
/**Write data into blockchain from (and/or) to multiple floID
@ -149,27 +145,27 @@
writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
return new Promise((resolve, reject) => {
if (!Array.isArray(senderPrivKeys))
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array")
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
if (!preserveRatio) {
let tmp = {};
let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
senderPrivKeys.forEach(key => tmp[key] = amount);
senderPrivKeys = tmp
}
senderPrivKeys = tmp;
};
if (!Array.isArray(receivers))
return reject("Invalid receivers: Receivers must be Array")
return reject("Invalid receivers: Receivers must be Array");
else {
let tmp = {};
let amount = floGlobals.sendAmt;
receivers.forEach(floID => tmp[floID] = amount);
receivers = tmp
}
receivers = tmp;
};
if (typeof data != "string")
data = JSON.stringify(data);
this.sendTxMultiple(senderPrivKeys, receivers, data)
.then(txid => resolve(txid))
.catch(error => reject(error))
})
.catch(error => reject(error));
});
},
/**Send Tx from (and/or) to multiple floID
@ -190,7 +186,7 @@
InvalidSenderAmountFor: [],
InvalidReceiverIDs: [],
InvalidReceiveAmountFor: []
}
};
let inputVal = 0,
outputVal = 0;
//Validate sender privatekeys (and send amount if passed)
@ -204,12 +200,12 @@
let floID = floCrypto.getFloID(key);
senders[floID] = {
wif: key
}
}
};
};
} catch (error) {
invalids.InvalidSenderPrivKeys.push(key)
}
})
invalids.InvalidSenderPrivKeys.push(key);
};
});
preserveRatio = true;
}
//conversion when privatekeys are passed with send amount
@ -219,32 +215,31 @@
if (!key)
invalids.InvalidSenderPrivKeys.push(key);
else {
if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[
key] <= 0)
invalids.InvalidSenderAmountFor.push(key)
if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
invalids.InvalidSenderAmountFor.push(key);
else
inputVal += senderPrivKeys[key];
let floID = floCrypto.getFloID(key);
senders[floID] = {
wif: key,
coins: senderPrivKeys[key]
}
}
};
};
} catch (error) {
invalids.InvalidSenderPrivKeys.push(key)
}
}
invalids.InvalidSenderPrivKeys.push(key);
};
};
preserveRatio = false;
}
};
//Validate the receiver IDs and receive amount
for (let floID in receivers) {
if (!floCrypto.validateAddr(floID))
invalids.InvalidReceiverIDs.push(floID)
invalids.InvalidReceiverIDs.push(floID);
if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
invalids.InvalidReceiveAmountFor.push(floID)
invalids.InvalidReceiveAmountFor.push(floID);
else
outputVal += receivers[floID];
}
};
//Reject if any invalids are found
for (let i in invalids)
if (!invalids[i].length)
@ -253,15 +248,14 @@
return reject(invalids);
//Reject if given inputVal and outputVal are not equal
if (!preserveRatio && inputVal != outputVal)
return reject(
`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`)
return reject(`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`);
} catch (error) {
return reject(error)
return reject(error);
}
//Get balance of senders
let promises = []
let promises = [];
for (let floID in senders)
promises.push(this.getBalance(floID))
promises.push(this.getBalance(floID));
Promise.all(promises).then(results => {
let totalBalance = 0,
totalFee = floGlobals.fee,
@ -273,26 +267,25 @@
let insufficient = [];
for (let floID in senders) {
balance[floID] = parseFloat(results.shift());
if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <=
totalFee) || (!preserveRatio && balance[floID] < senders[floID]
.coins + dividedFee))
insufficient.push(floID)
if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <= totalFee)
|| (!preserveRatio && balance[floID] < senders[floID].coins + dividedFee))
insufficient.push(floID);
totalBalance += balance[floID];
}
};
if (insufficient.length)
return reject({
InsufficientBalance: insufficient
})
});
//Calculate totalSentAmount and check if totalBalance is sufficient
let totalSendAmt = totalFee;
for (floID in receivers)
totalSendAmt += receivers[floID];
if (totalBalance < totalSendAmt)
return reject("Insufficient total Balance")
return reject("Insufficient total Balance");
//Get the UTXOs of the senders
let promises = []
let promises = [];
for (floID in senders)
promises.push(this.promisedAPI(`api/addr/${floID}/utxo`))
promises.push(this.promisedAPI(`api/addr/${floID}/utxo`));
Promise.all(promises).then(results => {
let wifSeq = [];
var trx = bitjs.transaction();
@ -306,21 +299,18 @@
sendAmt = senders[floID].coins + dividedFee;
let wif = senders[floID].wif;
let utxoAmt = 0.0;
for (let i = utxos.length - 1;
(i >= 0) && (utxoAmt < sendAmt); i--) {
for (let i = utxos.length - 1; (i >= 0) && (utxoAmt < sendAmt); i--)
if (utxos[i].confirmations) {
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
.scriptPubKey)
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
wifSeq.push(wif);
utxoAmt += utxos[i].amount;
}
}
};
if (utxoAmt < sendAmt)
return reject("Insufficient balance:" + floID);
let change = (utxoAmt - sendAmt);
if (change > 0)
trx.addoutput(floID, change);
}
};
for (floID in receivers)
trx.addoutput(floID, receivers[floID]);
trx.addflodata(floData.replace(/\n/g, ' '));
@ -329,10 +319,10 @@
var signedTxHash = trx.serialize();
this.broadcastTx(signedTxHash)
.then(txid => resolve(txid))
.catch(error => reject(error))
}).catch(error => reject(error))
}).catch(error => reject(error))
})
.catch(error => reject(error));
}).catch(error => reject(error));
}).catch(error => reject(error));
});
},
//Broadcast signed Tx in blockchain using API
@ -340,7 +330,7 @@
return new Promise((resolve, reject) => {
var request = new XMLHttpRequest();
var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
console.log(url)
console.log(url);
if (signedTxHash.length < 1)
reject("Empty Signature");
else {
@ -356,8 +346,8 @@
reject(request.responseText);
}
request.send(params);
}
})
};
});
},
//Read Txs of Address between from and to
@ -365,7 +355,7 @@
return new Promise((resolve, reject) => {
this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
.then(response => resolve(response))
.catch(error => reject(error))
.catch(error => reject(error));
});
},
@ -376,7 +366,7 @@
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${response.totalItems}0`)
.then(response => resolve(response.items))
.catch(error => reject(error));
}).catch(error => reject(error))
}).catch(error => reject(error));
});
},
@ -390,27 +380,23 @@
filter : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
*/
readData: function(addr, options = {}) {
options.limit = options.limit | 0
options.ignoreOld = options.ignoreOld | 0
options.limit = options.limit || 0;
options.ignoreOld = options.ignoreOld || 0;
return new Promise((resolve, reject) => {
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
var newItems = response.totalItems - options.ignoreOld;
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(
response => {
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
if (options.limit <= 0)
options.limit = response.items.length;
var filteredData = [];
for (i = 0; i < (response.totalItems - options.ignoreOld) &&
filteredData.length < options.limit; i++) {
if (options.sentOnly && response.items[i].vin[0].addr !==
addr)
if (options.sentOnly && response.items[i].vin[0].addr !== addr)
continue;
if (options.pattern) {
try {
let jsonContent = JSON.parse(response.items[i]
.floData)
if (!Object.keys(jsonContent).includes(options
.pattern))
let jsonContent = JSON.parse(response.items[i].floData)
if (!Object.keys(jsonContent).includes(options.pattern))
continue;
} catch (error) {
continue;
@ -419,7 +405,7 @@
if (options.filter && !options.filter(response.items[i].floData))
continue;
filteredData.push(response.items[i].floData);
}
};
resolve({
totalTxs: response.totalItems,
data: filteredData
@ -433,4 +419,4 @@
});
}
}
})(typeof global !== "undefined" ? global : window)
})(typeof global !== "undefined" ? global : window);

106
src/floCrypto.js
View File

@ -1,28 +1,28 @@
'use strict';
(function(GLOBAL) {
var floCrypto = GLOBAL.floCrypto = {}
var floCrypto = GLOBAL.floCrypto = {};
const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
const ecparams = EllipticCurve.getSECCurveByName("secp256k1");
function exponent1() {
return p.add(BigInteger.ONE).divide(BigInteger("4"))
}
return p.add(BigInteger.ONE).divide(BigInteger("4"));
};
function calculateY(x) {
let exp = exponent1();
// x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
}
return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p);
};
function getUncompressedPublicKey(compressedPublicKey) {
// Fetch x from compressedPublicKey
let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
const prefix = pubKeyBytes.shift() // remove prefix
const prefix = pubKeyBytes.shift(); // remove prefix
let prefix_modulus = prefix % 2;
pubKeyBytes.unshift(0) // add prefix 0
let x = new BigInteger(pubKeyBytes)
let xDecimalValue = x.toString()
pubKeyBytes.unshift(0); // add prefix 0
let x = new BigInteger(pubKeyBytes);
let xDecimalValue = x.toString();
// Fetch y
let y = calculateY(x);
let yDecimalValue = y.toString();
@ -35,7 +35,7 @@
x: xDecimalValue,
y: yDecimalValue
};
}
};
function getSenderPublicKeyString() {
privateKey = ellipticCurveEncryption.senderRandom();
@ -43,8 +43,8 @@
return {
privateKey: privateKey,
senderPublicKeyString: senderPublicKeyString
}
}
};
};
function deriveSharedKeySender(receiverCompressedPublicKey, senderPrivateKey) {
try {
@ -54,33 +54,33 @@
return senderDerivedKey;
} catch (error) {
return new Error(error);
}
}
};
};
function deriveReceiverSharedKey(senderPublicKeyString, receiverPrivateKey) {
return ellipticCurveEncryption.receiverSharedKeyDerivation(
senderPublicKeyString.XValuePublicString,
senderPublicKeyString.YValuePublicString, receiverPrivateKey);
}
};
function getReceiverPublicKeyString(privateKey) {
return ellipticCurveEncryption.receiverPublicString(privateKey);
}
};
function wifToDecimal(pk_wif, isPubKeyCompressed = false) {
let pk = Bitcoin.Base58.decode(pk_wif)
pk.shift()
pk.splice(-4, 4)
let pk = Bitcoin.Base58.decode(pk_wif);
pk.shift();
pk.splice(-4, 4);
//If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
if (isPubKeyCompressed == true) pk.pop()
pk.unshift(0)
privateKeyDecimal = BigInteger(pk).toString()
privateKeyHex = Crypto.util.bytesToHex(pk)
if (isPubKeyCompressed == true) pk.pop();
pk.unshift(0);
privateKeyDecimal = BigInteger(pk).toString();
privateKeyHex = Crypto.util.bytesToHex(pk);
return {
privateKeyDecimal: privateKeyDecimal,
privateKeyHex: privateKeyHex
}
}
};
};
//generate a random Interger within range
@ -88,7 +88,7 @@
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
};
//generate a random String within length (options : alphaNumeric chars only)
floCrypto.randString = function(length, alphaNumeric = true) {
@ -101,7 +101,7 @@
for (var i = 0; i < length; i++)
result += characters.charAt(Math.floor(Math.random() * characters.length));
return result;
}
};
//Encrypt Data using public-key
floCrypto.encryptData = function(data, publicKeyHex) {
@ -114,7 +114,7 @@
secret: secret,
senderPublicKeyString: senderECKeyData.senderPublicKeyString
};
}
};
//Decrypt Data using private-key
floCrypto.decryptData = function(data, privateKeyHex) {
@ -129,7 +129,7 @@
let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
return decryptMsg;
}
};
//Sign data using private-key
floCrypto.signData = function(data, privateKeyHex) {
@ -144,7 +144,7 @@
var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, key.priv);
var sighex = Crypto.util.bytesToHex(messageSign);
return sighex;
}
};
//Verify signatue of the data using public-key
floCrypto.verifySign = function(data, signatureHex, publicKeyHex) {
@ -156,7 +156,7 @@
var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger,
signature.r, signature.s, publicKeyPoint);
return verify;
}
};
//Generates a new flo ID and returns private-key, public-key and floID
floCrypto.generateNewID = function() {
@ -167,11 +167,11 @@
floID: key.getBitcoinAddress(),
pubKey: key.getPubKeyHex(),
privKey: key.getBitcoinWalletImportFormat()
}
};
} catch (e) {
console.error(e);
}
}
};
};
//Returns public-key from private-key
floCrypto.getPubKeyHex = function(privateKeyHex) {
@ -182,7 +182,7 @@
return null;
key.setCompressed(true);
return key.getPubKeyHex();
}
};
//Returns flo-ID from public-key or private-key
floCrypto.getFloID = function(keyHex) {
@ -195,8 +195,8 @@
return key.getBitcoinAddress();
} catch (e) {
return null;
}
}
};
};
//Verify the private-key for the given public-key or flo-ID
floCrypto.verifyPrivKey = function(privateKeyHex, publicHex_ID) {
@ -215,8 +215,8 @@
return false;
} catch (e) {
console.error(e);
}
}
};
};
//Check if the given Address is valid or not
floCrypto.validateAddr = function(inpAddr) {
@ -227,8 +227,8 @@
return true;
} catch {
return false;
}
}
};
};
//Split the str using shamir's Secret and Returns the shares
floCrypto.createShamirsSecretShares = function(str, total_shares, threshold_limit) {
@ -236,12 +236,12 @@
if (str.length > 0) {
var strHex = shamirSecretShare.str2hex(str);
return shamirSecretShare.share(strHex, total_shares, threshold_limit);
}
};
return false;
} catch {
return false
}
}
return false;
};
};
//Verifies the shares and str
floCrypto.verifyShamirsSecret = function(sharesArray, str) {
@ -250,13 +250,13 @@
try {
if (sharesArray.length > 0) {
var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
return (shamirSecretShare.hex2str(comb) === str ? true : false)
}
return (shamirSecretShare.hex2str(comb) === str ? true : false);
};
return false;
} catch {
return false;
}
}
};
};
//Returns the retrived secret by combining the shamirs shares
floCrypto.retrieveShamirSecret = function(sharesArray) {
@ -264,11 +264,11 @@
if (sharesArray.length > 0) {
var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
return shamirSecretShare.hex2str(comb);
}
};
return false;
} catch {
return false;
}
}
};
};
})(typeof global !== "undefined" ? global : window)
})(typeof global !== "undefined" ? global : window);

2
src/floGlobals.js
View File

@ -24,7 +24,7 @@ const floGlobals = {
errorFeedback - (Boolean) Send error (if any) feedback to the requestor
delayDelta - (Interger) Maximum allowed delay from the data-time
*/
}
};
(typeof global !== "undefined" ? global : window).cryptocoin = floGlobals.blockchain;
('object' === typeof module) ? module.export = floGlobals : null;

311
src/intra.js
View File

@ -19,7 +19,7 @@ const SUPERNODE_INDICATOR = '$',
RETRY_TIMEOUT = 5 * 60 * 1000, //5 mins
MIGRATE_WAIT_DELAY = 5 * 60 * 1000; //5 mins
var DB, refresher //container for database and refresher
var DB, refresher; //container for database and refresher
//List of node backups stored
const _list = {};
@ -36,7 +36,7 @@ Object.defineProperty(_list, 'get', {
else
return this[keys];
}
})
});
Object.defineProperty(_list, 'stored', {
get: function() {
return Object.keys(this);
@ -44,7 +44,7 @@ Object.defineProperty(_list, 'stored', {
});
Object.defineProperty(_list, 'serving', {
get: function() {
let serveList = []
let serveList = [];
for (let id in this)
if (this[id] === 0)
serveList.push(id);
@ -66,12 +66,12 @@ function NodeContainer() {
if (_onclose)
_ws.onclose = _onclose;
}
})
});
Object.defineProperty(this, 'id', {
get: function() {
return _id;
}
})
});
Object.defineProperty(this, 'readyState', {
get: function() {
if (_ws instanceof WebSocket)
@ -79,7 +79,7 @@ function NodeContainer() {
else
return null;
}
})
});
Object.defineProperty(this, 'send', {
value: function(packet) {
_ws.send(packet);
@ -90,28 +90,28 @@ function NodeContainer() {
if (fn instanceof Function)
_onmessage = fn;
}
})
});
Object.defineProperty(this, 'onclose', {
set: function(fn) {
if (fn instanceof Function)
_onclose = fn;
}
})
});
Object.defineProperty(this, 'is', {
value: function(ws) {
return ws === _ws;
}
})
});
Object.defineProperty(this, 'close', {
value: function() {
if (_ws.readyState === 1) {
_ws.onclose = () => console.warn('Closing: ' + _id)
_ws.onclose = () => console.warn('Closing: ' + _id);
_ws.close();
}
};
_ws = _id = undefined;
}
})
}
});
};
//Container for next-node
const _nextNode = new NodeContainer();
@ -123,19 +123,19 @@ _prevNode.onmessage = evt => processTaskFromPrevNode(evt.data);
_prevNode.onclose = evt => _prevNode.close();
//Packet processing
const packet_ = {}
const packet_ = {};
packet_.constuct = function(message) {
const packet = {
from: myFloID,
message: message,
time: Date.now()
}
};
packet.sign = floCrypto.signData(this.s(packet), myPrivKey);
return SUPERNODE_INDICATOR + JSON.stringify(packet)
}
return SUPERNODE_INDICATOR + JSON.stringify(packet);
};
packet_.s = d => [JSON.stringify(d.message), d.time].join("|");
packet_.parse = function(str) {
let packet = JSON.parse(str.substring(SUPERNODE_INDICATOR.length))
let packet = JSON.parse(str.substring(SUPERNODE_INDICATOR.length));
let curTime = Date.now();
if (packet.time > curTime - floGlobals.sn_config.delayDelta &&
packet.from in floGlobals.supernodes &&
@ -143,8 +143,8 @@ packet_.parse = function(str) {
if (!Array.isArray(packet.message))
packet.message = [packet.message];
return packet;
}
}
};
};
//-----NODE CONNECTORS (WEBSOCKET)-----
@ -152,44 +152,44 @@ packet_.parse = function(str) {
function connectToNode(snID) {
return new Promise((resolve, reject) => {
if (!(snID in floGlobals.supernodes))
return reject(`${snID} is not a supernode`)
return reject(`${snID} is not a supernode`);
const ws = new WebSocket("wss://" + floGlobals.supernodes[nextNodeID].uri + "/");
ws.on("error", () => reject(`${snID} is offline`));
ws.on('open', () => resolve(ws));
})
}
});
};
//Connect to Node websocket thats online
function connectToActiveNode(snID, reverse = false) {
return new Promise((resolve, reject) => {
if (!(snID in floGlobals.supernodes))
return reject(`${snID} is not a supernode`)
return reject(`${snID} is not a supernode`);
if (snID === myFloID)
return reject(`Reached end of circle. Next node avaiable is self`)
return reject(`Reached end of circle. Next node avaiable is self`);
connectToNode(snID)
.then(ws => resolve(ws))
.catch(error => {
var next = reverse ? kBucket.prevNode(snID) : kBucket.nextNode(snID)
var next = (reverse ? kBucket.prevNode(snID) : kBucket.nextNode(snID));
connectToActiveNode(next, reverse)
.then(ws => resolve(ws))
.catch(error => reject(error))
})
})
}
.catch(error => reject(error));
});
});
};
//Connect to next available node
function connectToNextNode() {
return new Promise((resolve, reject) => {
let nextNodeID = kBucket.nextNode(nodeID);
connectToActiveNode(nextNodeID).then(ws => {
_nextNode.set(nextNodeID, ws)
_nextNode.set(nextNodeID, ws);
_nextNode.send(packet_.constuct({
type: BACKUP_HANDSHAKE_INIT
}));
resolve("BACKUP_HANDSHAKE_INIT: " + nextNodeID)
}).catch(error => reject(error))
})
}
resolve("BACKUP_HANDSHAKE_INIT: " + nextNodeID);
}).catch(error => reject(error));
});
};
function connectToAliveNodes(nodes = null) {
if (!Array.isArray(nodes)) nodes = Object.keys(floGlobals.supernodes);
@ -199,9 +199,9 @@ function connectToAliveNodes(nodes = null) {
nodes.forEach((n, i) =>
ws_connections[n] = (results.status === "fulfilled") ? results[i].value : null);
resolve(ws_connections);
}).catch(error => reject(error))
})
}
});
});
};
//Connect to all given nodes [Array] (Default: All super-nodes)
function connectToAllActiveNodes(nodes = null) {
@ -212,9 +212,9 @@ function connectToAllActiveNodes(nodes = null) {
nodes.forEach((n, i) =>
ws_connections[n] = (results.status === "fulfilled") ? results[i].value : null);
resolve(ws_connections);
}).catch(error => reject(error))
})
}
});
});
};
//-----PROCESS TASKS-----
@ -223,90 +223,90 @@ function processTaskFromNextNode(packet) {
var {
from,
message
} = packet_.parse(packet)
} = packet_.parse(packet);
if (message) {
message.forEach(task => {
switch (task.type) {
case RECONNECT_NEXT_NODE: //Triggered when a node inbetween is available
reconnectNextNode()
reconnectNextNode();
break;
case BACKUP_HANDSHAKE_END:
handshakeEnd()
handshakeEnd();
break;
case DATA_REQUEST:
sendStoredData(task.nodes, _nextNode)
sendStoredData(task.nodes, _nextNode);
break;
case DATA_SYNC:
dataSyncIndication(task.id, task.status, from)
dataSyncIndication(task.id, task.status, from);
break;
case STORE_BACKUP_DATA:
storeBackupData(task.data)
storeBackupData(task.data);
break;
default:
console.log("Invalid task type:" + task.type + "from next-node")
}
})
}
}
console.log("Invalid task type:" + task.type + "from next-node");
};
});
};
};
//Tasks from prev-node
function processTaskFromPrevNode(packet) {
var {
from,
message
} = packet_.parse(packet)
} = packet_.parse(packet);
if (message) {
message.forEach(task => {
switch (task.type) {
case ORDER_BACKUP:
orderBackup(task.order)
orderBackup(task.order);
break;
case STORE_BACKUP_DATA:
storeBackupData(task.data, from, packet)
storeBackupData(task.data, from, packet);
break;
case TAG_BACKUP_DATA:
tagBackupData(task.data, from, packet)
tagBackupData(task.data, from, packet);
break;
case DATA_REQUEST:
sendStoredData(task.nodes, _prevNode)
sendStoredData(task.nodes, _prevNode);
break;
case DATA_SYNC:
dataSyncIndication(task.id, task.status, from)
dataSyncIndication(task.id, task.status, from);
break;
case DELETE_MIGRATED_DATA:
deleteMigratedData(task.data, from, packet)
deleteMigratedData(task.data, from, packet);
break;
default:
console.log("Invalid task type:" + task.type + "from prev-node")
}
console.log("Invalid task type:" + task.type + "from prev-node");
};
});
}
}
};
};
//Tasks from any supernode
function processTaskFromSupernode(packet, ws) {
var {
from,
message
} = packet_.parse(packet)
} = packet_.parse(packet);
if (message) {
message.forEach(task => {
switch (task.type) {
case BACKUP_HANDSHAKE_INIT:
handshakeMid(from, ws)
handshakeMid(from, ws);
break;
case STORE_MIGRATED_DATA:
storeMigratedData(task.data)
storeMigratedData(task.data);
break;
case INITIATE_REFRESH:
initiateRefresh()
initiateRefresh();
break;
default:
console.log("Invalid task type:" + task.type + "from super-node")
}
console.log("Invalid task type:" + task.type + "from super-node");
};
});
}
}
};
};
//-----HANDSHAKE PROCESS-----
@ -323,21 +323,21 @@ function handshakeMid(id, ws) {
_prevNode.set(id, ws);
_prevNode.send(packet_.constuct({
type: BACKUP_HANDSHAKE_END
}))
}));
} else {
//Incorrect order, existing prev-node is already after the incoming node
ws.send(packet_.constuct({
type: RECONNECT_NEXT_NODE
}))
}));
return;
}
};
} else {
//set the new prev-node connection
_prevNode.set(id, ws);
_prevNode.send(packet_.constuct({
type: BACKUP_HANDSHAKE_END
}))
}
}));
};
//Reorder storelist
let nodes = kBucket.innerNodes(_prevNode.id, myFloID).concat(myFloID),
req_sync = [],
@ -351,19 +351,19 @@ function handshakeMid(id, ws) {
default:
_list[n] = 0;
new_order.push(n);
}
};
});
if (!req_sync.length && !new_order.length)
return; //No order change and no need for any data sync
else
handshakeMid.requestData(req_sync, new_order);
}
};
handshakeMid.requestData = function(req_sync, new_order) {
if (handshakeMid.timeout) {
clearTimeout(handshakeMid.timeout)
clearTimeout(handshakeMid.timeout);
delete handshakeMid.timeout;
}
};
Promise.allSettled(req_sync.map(n => DB.createGetLastLog(n))).then(result => {
let tasks = [],
lastlogs = {},
@ -375,7 +375,7 @@ handshakeMid.requestData = function(req_sync, new_order) {
if (result[i].status === "fulfilled")
lastlogs[s] = result[i].value;
else
failed.push(s)
failed.push(s);
});
if (Object.keys(lastlogs).length)
tasks.push({
@ -384,29 +384,29 @@ handshakeMid.requestData = function(req_sync, new_order) {
});
new_order.forEach(n => {
if (failed.includes(n))
failed_order.push(n)
failed_order.push(n);
else
order.push(n)
order.push(n);
});
if (order.length)
tasks.push({
type: ORDER_BACKUP,
order: _list.get(order)
})
});
_nextNode.send(packet_.constuct(tasks));
if (failed.length)
handshakeMid.timeout = setTimeout(_ => handshakeMid.requestData(failed, failed_order), RETRY_TIMEOUT)
handshakeMid.timeout = setTimeout(_ => handshakeMid.requestData(failed, failed_order), RETRY_TIMEOUT);
});
}
};
//Complete handshake
function handshakeEnd() {
console.log("Backup connected: " + _nextNode.id)
console.log("Backup connected: " + _nextNode.id);
_nextNode.send(packet_.constuct({
type: ORDER_BACKUP,
order: _list.get()
}))
}
}));
};
//Reconnect to next available node
function reconnectNextNode() {
@ -420,9 +420,9 @@ function reconnectNextNode() {
for (let sn in floGlobals.supernodes)
DB.createTable(sn)
.then(result => _list[sn] = 0)
.catch(error => console.error(error))
})
}
.catch(error => console.error(error));
});
};
//-----BACKUP TASKS-----
@ -435,20 +435,20 @@ function orderBackup(order) {
if (order[n] >= floGlobals.sn_config.backupDepth)
DB.dropTable(n).then(_ => null)
.catch(error => console.error(error))
.finally(_ => _list.delete(n))
.finally(_ => _list.delete(n));
else if (_list[n] !== 0 || !cur_serve.includes(n)) {
_list[n] = order[n] + 1;
new_order.push(n);
}
}
}
};
};
};
if (new_order.length) {
_nextNode.send(packet_.constuct({
type: ORDER_BACKUP,
order: _list.get(new_order)
}));
}
}
};
};
//Send stored data
function sendStoredData(lastlogs, node) {
@ -459,50 +459,48 @@ function sendStoredData(lastlogs, node) {
type: DATA_SYNC,
id: n,
status: true
}))
console.info(`START: ${snID} data sync(send) to ${node.id}`)
}));
console.info(`START: ${snID} data sync(send) to ${node.id}`);
//TODO: efficiently handle large number of data instead of loading all into memory
result.forEach(d => node.send(packet_.constuct({
type: STORE_BACKUP_DATA,
data: d
})))
console.info(`END: ${snID} data sync(send) to ${node.id}`)
})));
console.info(`END: ${snID} data sync(send) to ${node.id}`);
node.send(packet_.constuct({
type: DATA_SYNC,
id: n,
status: false
}))
}).catch(error => console.error(error))
}
}
}
}));
}).catch(error => console.error(error));
};
};
};
//Indicate sync of data
function dataSyncIndication(snID, status, from) {
console.info(`${status ? 'START':'END'}: ${snID} data sync(receive) form ${from}`);
}
};
//Store (backup) data
function storeBackupData(data, from, packet) {
let closestNode = kBucket.closestNode(data.receiverID);
if (_list.stored.includes(closestNode)) {
DB.storeData(closestNode, data);
if (_list[closestNode] < floGlobals.sn_config.backupDepth &&
_nextNode.id !== from)
if (_list[closestNode] < floGlobals.sn_config.backupDepth && _nextNode.id !== from)
_nextNode.send(packet);
}
}
};
};
//Tag (backup) data
function tagBackupData(data, from, packet) {
let closestNode = kBucket.closestNode(data.receiverID);
if (_list.stored.includes(closestNode)) {
DB.storeTag(closestNode, data);
if (_list[closestNode] < floGlobals.sn_config.backupDepth &&
_nextNode.id !== from)
if (_list[closestNode] < floGlobals.sn_config.backupDepth && _nextNode.id !== from)
_nextNode.send(packet);
}
}
};
};
//Store (migrated) data
function storeMigratedData(data) {
@ -513,36 +511,35 @@ function storeMigratedData(data) {
type: STORE_BACKUP_DATA,
data: data
}));
}
}
};
};
//Delete (migrated) data
function deleteMigratedData(old_sn, vectorClock, receiverID, from, packet) {
let closestNode = kBucket.closestNode(receiverID);
if (old_sn !== closestNode && _list.stored.includes(old_sn)) {
DB.deleteData(old_sn, vectorClock);
if (_list[old_sn] < floGlobals.sn_config.backupDepth &&
_nextNode.id !== from)
if (_list[old_sn] < floGlobals.sn_config.backupDepth && _nextNode.id !== from)
_nextNode.send(packet);
}
}
};
};
function initiateRefresh() {
refresher.invoke(false)
}
refresher.invoke(false);
};
//Forward incoming to next node
function forwardToNextNode(mode, data) {
var modeMap = {
'TAG': TAG_BACKUP_DATA,
'DATA': STORE_BACKUP_DATA
}
};
if (mode in modeMap && _nextNode.id)
_nextNode.send(packet_.constuct({
type: modeMap[mode],
data: data
}));
}
};
//Data migration processor
function dataMigration(node_change, flag) {
@ -557,28 +554,28 @@ function dataMigration(node_change, flag) {
if (del_nodes.includes(_prevNode.id)) {
_list[_prevNode.id] = 0; //Temporary serve for the deleted node
_prevNode.close();
}
};
setTimeout(() => {
//reconnect next node if current next node is deleted
if (del_nodes.includes(_nextNode.id))
reconnectNextNode();
else { //reconnect next node if there are newly added nodes in between self and current next node
let innerNodes = kBucket.innerNodes(myFloID, _nextNode.id)
let innerNodes = kBucket.innerNodes(myFloID, _nextNode.id);
if (new_nodes.filter(n => innerNodes.includes(n)).length)
reconnectNextNode();
}
};
setTimeout(() => {
dataMigration.process_new(new_nodes);
dataMigration.process_del(del_nodes);
}, MIGRATE_WAIT_DELAY);
}, MIGRATE_WAIT_DELAY)
}
}, MIGRATE_WAIT_DELAY);
};
//data migration sub-process: Deleted nodes
dataMigration.process_del = async function(del_nodes) {
if (!del_nodes.length)
return;
let process_nodes = del_nodes.filter(n => _list.serving.includes(n))
let process_nodes = del_nodes.filter(n => _list.serving.includes(n));
if (process_nodes.length) {
connectToAllActiveNodes().then(ws_connections => {
let remaining = process_nodes.length;
@ -599,30 +596,30 @@ dataMigration.process_del = async function(del_nodes) {
type: STORE_MIGRATED_DATA,
data: d
}));
})
});
console.info(`END: Data migration for ${n}`);
_list.delete(n);
DB.dropTable(n);
remaining--;
}).catch(error => reject(error))
}).catch(error => reject(error));
});
const interval = setInterval(() => {
if (remaining <= 0) {
for (let c in ws_connections)
if (ws_connections[c])
ws_connections[c].close()
ws_connections[c].close();
clearInterval(interval);
}
};
}, RETRY_TIMEOUT);
}).catch(error => reject(error))
}
});
};
del_nodes.forEach(n => {
if (!process_nodes.includes(n) && _list.stored.includes(n)) {
_list.delete(n);
DB.dropTable(n);
}
})
}
};
});
};
//data migration sub-process: Added nodes
dataMigration.process_new = async function(new_nodes) {
@ -654,34 +651,34 @@ dataMigration.process_new = async function(new_nodes) {
receiverID: d.receiverID,
snID: n
}));
}
})
};
});
remaining--;
}).catch(error => reject(error))
}).catch(error => reject(error));
});
const interval = setInterval(() => {
if (remaining <= 0) {
for (let c in ws_connections)
if (ws_connections[c])
ws_connections[c].close()
ws_connections[c].close();
clearInterval(interval);
}
};
}, RETRY_TIMEOUT);
}).catch(error => reject(error))
}
});
};
dataMigration.intimateAllNodes = function() {
connectToAliveNodes().then(ws_connections => {
let packet = packet_.constuct({
type: INITIATE_REFRESH
})
});
for (let n in ws_connections)
if (ws_connections[n]) {
ws_connections[n].send(packet)
ws_connections[n].close()
}
}).catch(error => reject(error))
}
ws_connections[n].send(packet);
ws_connections[n].close();
};
});
};
//-----EXPORTS-----
module.exports = {
@ -691,9 +688,9 @@ module.exports = {
SUPERNODE_INDICATOR,
_list,
set DB(db) {
DB = db
DB = db;
},
set refresher(r) {
refresher = r
refresher = r;
}
}
};

76
src/kBucket.js
View File

@ -1,24 +1,24 @@
'use strict';
require('./lib/BuildKBucket')
(function(GLOBAL) {
var kBucket = GLOBAL.kBucket = {}
var kBucket = GLOBAL.kBucket = {};
var SNKB, SNCO;
function decodeID(floID) {
let k = bitjs.Base58.decode(floID)
k.shift()
k.splice(-4, 4)
let k = bitjs.Base58.decode(floID);
k.shift();
k.splice(-4, 4);
const decodedId = Crypto.util.bytesToHex(k);
const nodeIdBigInt = new BigInteger(decodedId, 16);
const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
const nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
return nodeIdNewInt8Array;
}
};
function distanceOf(floID) {
let decodedId = decodeID(floID);
return SNKB.distance(SNKB.localNodeId, decodedId);
}
};
function constructKB(list, refID) {
let KB = new BuildKBucket({
@ -29,7 +29,7 @@ require('./lib/BuildKBucket')
floID: floID
}));
return KB;
}
};
kBucket.launch = function() {
return new Promise((resolve, reject) => {
@ -39,73 +39,73 @@ require('./lib/BuildKBucket')
SNKB = constructKB(superNodeList, masterID);
SNCO = superNodeList.map(sn => [distanceOf(sn), sn])
.sort((a, b) => a[0] - b[0])
.map(a => a[1])
.map(a => a[1]);
resolve('SuperNode KBucket formed');
} catch (error) {
reject(error);
}
};
});
}
};
kBucket.innerNodes = function(id1, id2) {
if (!SNCO.includes(id1) || !SNCO.includes(id2))
throw Error('Given nodes are not supernode');
let iNodes = []
let iNodes = [];
for (let i = SNCO.indexOf(id1) + 1; SNCO[i] != id2; i++) {
if (i < SNCO.length)
iNodes.push(SNCO[i])
else i = -1
}
return iNodes
}
iNodes.push(SNCO[i]);
else i = -1;
};
return iNodes;
};
kBucket.outterNodes = function(id1, id2) {
if (!SNCO.includes(id1) || !SNCO.includes(id2))
throw Error('Given nodes are not supernode');
let oNodes = []
let oNodes = [];
for (let i = SNCO.indexOf(id2) + 1; SNCO[i] != id1; i++) {
if (i < SNCO.length)
oNodes.push(SNCO[i])
else i = -1
}
return oNodes
}
oNodes.push(SNCO[i]);
else i = -1;
};
return oNodes;
};
kBucket.prevNode = function(id, N = 1) {
let n = N || SNCO.length;
if (!SNCO.includes(id))
throw Error('Given node is not supernode');
let pNodes = []
let pNodes = [];
for (let i = 0, j = SNCO.indexOf(id) - 1; i < n; j--) {
if (j == SNCO.indexOf(id))
break;
else if (j > -1)
pNodes[i++] = SNCO[j]
else j = SNCO.length
}
return (N == 1 ? pNodes[0] : pNodes)
}
pNodes[i++] = SNCO[j];
else j = SNCO.length;
};
return (N == 1 ? pNodes[0] : pNodes);
};
kBucket.nextNode = function(id, N = 1) {
let n = N || SNCO.length;
if (!SNCO.includes(id))
throw Error('Given node is not supernode');
let nNodes = []
let nNodes = [];
for (let i = 0, j = SNCO.indexOf(id) + 1; i < n; j++) {
if (j == SNCO.indexOf(id))
break;
else if (j < SNCO.length)
nNodes[i++] = SNCO[j]
else j = -1
}
return (N == 1 ? nNodes[0] : nNodes)
}
nNodes[i++] = SNCO[j];
else j = -1;
};
return (N == 1 ? nNodes[0] : nNodes);
};
kBucket.closestNode = function(id, N = 1) {
let decodedId = decodeID(id);
let n = N || SNCO.length;
let cNodes = SNKB.closest(decodedId, n)
.map(k => k.floID)
return (N == 1 ? cNodes[0] : cNodes)
}
})(typeof global !== "undefined" ? global : window)
.map(k => k.floID);
return (N == 1 ? cNodes[0] : cNodes);
};
})(typeof global !== "undefined" ? global : window);

106
src/main.js
View File

@ -1,24 +1,26 @@
const config = require("../config.json")
global.floGlobals = require("./floGlobals")
require('./set_globals')
require('./lib')
require('./kBucket')
require('./floCrypto')
require('./floBlockchainAPI')
const Database = require("./database")
const intra = require('./intra')
const client = require('./client')
const Server = require('./server')
const config = require("../config.json");
global.floGlobals = require("./floGlobals");
require('./set_globals');
require('./lib');
require('./kBucket');
require('./floCrypto');
require('./floBlockchainAPI');
const Database = require("./database");
const intra = require('./intra');
const client = require('./client');
const Server = require('./server');
var DB; //Container for Database object
function startNode() {
//Set myPrivKey, myPubKey, myFloID
global.myPrivKey = config["privateKey"]
global.myPubKey = floCrypto.getPubKeyHex(config["privateKey"])
global.myFloID = floCrypto.getFloID(config["privateKey"])
global.myPrivKey = config["privateKey"];
global.myPubKey = floCrypto.getPubKeyHex(config["privateKey"]);
global.myFloID = floCrypto.getFloID(config["privateKey"]);
console.info("Logged In as " + myFloID);
//DB connect
Database(config["sql_user"], config["sql_pwd"], config["sql_db"], config["sql_host"]).then(db => {
console.info("Connected to Database");
DB = db;
//Set DB to client and intra scripts
intra.DB = DB;
@ -36,19 +38,19 @@ function startNode() {
const server = new Server(config["port"], client, intra);
server.refresher = refreshData;
intra.refresher = refreshData;
}).catch(error => reject(error))
}).catch(error => reject(error))
}
}).catch(error => reject(error));
}).catch(error => reject(error));
};
function loadBase(DB) {
return new Promise((resolve, reject) => {
DB.createBase().then(result => {
DB.getBase(DB)
.then(result => resolve(result))
.catch(error => reject(error))
}).catch(error => reject(error))
})
}
.catch(error => reject(error));
}).catch(error => reject(error));
});
};
const refreshData = {
count: null,
@ -56,33 +58,33 @@ const refreshData = {
invoke(flag = true) {
this.count = floGlobals.sn_config.refreshDelay;
refreshBlockchainData(this.base, flag).then(result => {
console.log(result)
console.log(result);
diskCleanUp(this.base)
.then(result => console.info(result))
.catch(warn => console.warn(warn))
}).catch(error => console.error(error))
.catch(warn => console.warn(warn));
}).catch(error => console.error(error));
},
get countdown() {
this.count--;
if (this.count <= 0)
this.invoke();
}
}
};
function refreshBlockchainData(base, flag) {
return new Promise((resolve, reject) => {
readSupernodeConfigFromAPI(base, flag).then(result => {
console.log(result)
console.log(result);
kBucket.launch().then(result => {
console.log(result)
console.log(result);
readAppSubAdminListFromAPI(base)
.then(result => console.log(result))
.catch(warn => console.warn(warn))
.finally(_ => resolve("Refreshed Data from blockchain"))
}).catch(error => reject(error))
}).catch(error => reject(error))
})
}
.finally(_ => resolve("Refreshed Data from blockchain"));
}).catch(error => reject(error));
}).catch(error => reject(error));
});
};
function readSupernodeConfigFromAPI(base, flag) {
return new Promise((resolve, reject) => {
@ -92,7 +94,7 @@ function readSupernodeConfigFromAPI(base, flag) {
pattern: "SuperNodeStorage"
}).then(result => {
let promises = [],
node_change = {}
node_change = {};
result.data.reverse().forEach(data => {
var content = JSON.parse(data).SuperNodeStorage;
if (content.removeNodes)
@ -103,7 +105,7 @@ function readSupernodeConfigFromAPI(base, flag) {
delete node_change[sn];
else
node_change[sn] = false;
}
};
if (content.newNodes)
for (let sn in content.newNodes) {
promises.push(DB.addSuperNode(sn, content.newNodes[sn].pubKey, content.newNodes[sn].uri));
@ -115,22 +117,22 @@ function readSupernodeConfigFromAPI(base, flag) {
delete node_change[sn];
else
node_change[sn] = true;
}
};
if (content.config)
for (let c in content.config) {
promises.push(DB.setConfig(c, content.config[c]));
base.sn_config[c] = content.config[c];
}
};
if (content.removeApps)
for (let app of content.removeApps) {
promises.push(DB.rmApp(app));
delete base.appList;
}
};
if (content.addApps)
for (let app in content.addApps) {
promises.push(DB.addApp(app, content.addApps[app]));
base.appList[app] = content.addApps[app];
}
};
});
promises.push(DB.setLastTx(floGlobals.SNStorageID, result.totalTxs));
//Check if all save process were successful
@ -142,11 +144,11 @@ function readSupernodeConfigFromAPI(base, flag) {
});
//Process data migration if nodes are changed
if (Object.keys(node_change))
intra.dataMigration(node_change, flag)
intra.dataMigration(node_change, flag);
resolve('Updated Supernode Configuration');
}).catch(error => reject(error))
})
}
}).catch(error => reject(error));
});
};
function readAppSubAdminListFromAPI(base) {
var promises = [];
@ -175,9 +177,9 @@ function readAppSubAdminListFromAPI(base) {
console.warn(`SubAdmin list for app(${app}) might not have been saved in database`);
});
resolve("Loaded subAdmin List for APP:" + app);
}).catch(error => reject([app, error]))
}).catch(error => reject([app, error]));
}));
}
};
return new Promise((resolve, reject) => {
Promise.allSettled(promises).then(results => {
if (results.reduce((a, r) => r.status === "rejected" ? ++a : a, 0)) {
@ -187,8 +189,8 @@ function readAppSubAdminListFromAPI(base) {
} else
resolve("Loaded subAdmin List for all APPs successfully");
});
})
}
});
};
function diskCleanUp(base) {
return new Promise((resolve, reject) => {
@ -201,18 +203,18 @@ function diskCleanUp(base) {
//for each authorised app: delete unofficial data (untaged, unknown sender/receiver)
for (let app in base.appList)
promises.push(DB.clearAuthorisedAppData(sn, app, base.appList[app], base.subAdmins[app], time));
})
});
Promise.allSettled(promises).then(results => {
let failed = results.filter(r => r.status === "rejected").map(r => r.reason)
let failed = results.filter(r => r.status === "rejected").map(r => r.reason);
if (failed.length) {
console.error(JSON.stringify(failed));
let success = results.length - failed.length;
reject(`Disk clean-up process has failed at ${100 * success/results.length}%. (Success:${success}|Failed:${failed.count})`)
reject(`Disk clean-up process has failed at ${100 * success/results.length}%. (Success:${success}|Failed:${failed.count})`);
} else
resolve("Disk clean-up process finished successfully (100%)");
}).catch(error => reject(error))
})
}
}).catch(error => reject(error));
});
};
module.exports = startNode;

43
src/server.js
View File

@ -1,5 +1,5 @@
const http = require('http')
const WebSocket = require('ws')
const http = require('http');
const WebSocket = require('ws');
module.exports = function Server(port, client, intra) {
@ -14,13 +14,12 @@ module.exports = function Server(port, client, intra) {
var request = JSON.parse(req.url.substring(i));
client.processRequestFromUser(request)
.then(result => res.end(JSON.parse(result[0])))
.catch(error => res.end(error.toString()))
}
})
}
if (req.method === "POST") {
.catch(error => res.end(error.toString()));
};
});
} else if (req.method === "POST") {
let data = '';
req.on('data', chunk => data += chunk)
req.on('data', chunk => data += chunk);
req.on('end', () => {
console.log(data);
//process the data storing
@ -29,17 +28,17 @@ module.exports = function Server(port, client, intra) {
if (result[1]) {
refresher.countdown;
if (result[1] === 'DATA')
sendToLiveRequests(result[0])
intra.forwardToNextNode(result[1], result[0])
}
}).catch(error => res.end(error.toString()))
})
}
sendToLiveRequests(result[0]);
intra.forwardToNextNode(result[1], result[0]);
};
}).catch(error => res.end(error.toString()));
});
};
});
server.listen(port, (err) => {
if (!err)
console.log(`Server running at port ${port}`);
})
});
const wsServer = new WebSocket.Server({
server
@ -53,14 +52,14 @@ module.exports = function Server(port, client, intra) {
var request = JSON.parse(message);
client.processRequestFromUser(JSON.parse(message))
.then(result => {
ws.send(JSON.parse(result[0]))
ws.send(JSON.parse(result[0]));
ws._liveReq = request;
}).catch(error => {
if (floGlobals.sn_config.errorFeedback)
ws.send(error.toString())
})
}
}
ws.send(error.toString());
});
};
};
});
Object.defineProperty(this, "http", {
@ -71,5 +70,5 @@ module.exports = function Server(port, client, intra) {
});
Object.defineProperty(this, "refresher", {
set: (r) => refresher = r
})
}
});
};

2
src/set_globals.js
View File

@ -3,6 +3,6 @@
global.fetch = require("node-fetch");
//Set browser paramaters from param.json
const param = require('../param.json')
const param = require('../param.json');
for(let p in param)
global[p] = param[p];