API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 14th, 2019
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.30 KB | None | 0 0
raw download clone embed print report
  1. import * as fs from 'fs';
  2. import * as util from 'util';
  3.  
  4. import { EventTimestamp } from './eventTimestamp';
  5. import { Counts, SubCounts } from './genericCounts';
  6. import { checkTestIntegrity } from './integrityCheck';
  7. import { EventType, ILogEvent } from './logEvent';
  8. import { info } from './logger';
  9. import { LogResults } from './logResults';
  10. import { INode, INodeMap } from './node';
  11. import { Pod } from './pod';
  12. import { TestConfig } from './testConfig';
  13. import { ITx, ITxMap } from './tx';
  14.  
  15. const localTestConfig = new TestConfig(60, 2, true, 1);
  16.  
  17. enum ValidatorType {
  18. CURRENT = 0,
  19. PREVIOUS = 1,
  20. SNAPSHOT = 2,
  21. }
  22.  
  23. enum LogType {
  24. FIREBASE = 0,
  25. WINSTON = 1,
  26. MONGODB = 2,
  27. }
  28.  
  29. const getGlobalResults = (): LogResults => globalResults;
  30. let startTime: number;
  31. let endTime: number;
  32. let expectedEndTime: number = Date.now() * 2;
  33. let globalResults = {} as LogResults;
  34.  
  35. const parseResults = (results: any, type: LogType, printResults: boolean): void => {
  36. type === LogType.WINSTON && (parseWinstonResults(results, printResults));
  37. type === LogType.FIREBASE && (parseFirebaseResults(results, printResults));
  38. type === LogType.MONGODB && (parseMongoDBResults(results, printResults));
  39. };
  40.  
  41. const parseWinstonResults = (results: any, printResults: boolean): void => {
  42. const firstEntry: ILogEvent = results.file[0];
  43. const lastEntry: ILogEvent = results.file[results.file.length - 1];
  44. startTime = Date.parse(<string>firstEntry.timestamp);
  45. endTime = Date.parse(<string>lastEntry.timestamp);
  46. parseCommonResults(results.file, printResults, startTime, endTime);
  47. };
  48.  
  49. const parseFirebaseResults = (results: any, printResults: boolean): void => {
  50. const keys = Object.keys(results);
  51. const firstEntry: ILogEvent = results[keys[0]];
  52. const lastEntry: ILogEvent = results[keys[keys.length - 1]];
  53. startTime = <number>firstEntry.timestamp;
  54. endTime = <number>lastEntry.timestamp;
  55. const resultArray = [];
  56. for (let i = 0; i < keys.length; i += 1) {
  57. const key = keys[i];
  58. resultArray.push(results[key]);
  59. }
  60. parseCommonResults(resultArray, printResults, startTime, endTime);
  61. };
  62.  
  63. const parseMongoDBResults = (results: any, printResults: boolean): void => {
  64. const firstEntry: ILogEvent = results[0];
  65. const lastEntry: ILogEvent = results[results.length - 1];
  66. startTime = <number>firstEntry.timestamp;
  67. endTime = <number>lastEntry.timestamp;
  68. info(`Log Start Time: ${startTime}`);
  69. info(`Log End Time: ${endTime}`);
  70. parseCommonResults(results, printResults, startTime, endTime);
  71. // const _results = JSON.parse(results);
  72. // const keys = Object.keys(_results);
  73. // const firstEntry: ILogEvent = _results[keys[0]];
  74. // const lastEntry: ILogEvent = _results[keys[keys.length - 1]];
  75. // startTime = <number>firstEntry.timestamp;
  76. // endTime = <number>lastEntry.timestamp;
  77. // const resultArray = [];
  78. // for (let i = 0; i < keys.length; i += 1) {
  79. // const key = keys[i];
  80. // resultArray.push(_results[key])
  81. // }
  82. // parseCommonResults(resultArray, printResults, startTime, endTime);
  83. };
  84.  
  85. const parseCommonResults = (results: any, printResults: boolean, startTime: number, endTime: number): void => {
  86. const txMap: ITxMap = {};
  87. const nodeMap: INodeMap = {};
  88. for (let i = 0; i < results.length; i += 1) {
  89. const result: ILogEvent = results[i];
  90. // console.dir(result);
  91. const {
  92. sender,
  93. receiver,
  94. connectionTo,
  95. owner,
  96. timestamp,
  97. transactionId,
  98. eventType,
  99. testConfig,
  100. }: ILogEvent = result;
  101. const nTimestamp: number = typeof timestamp === 'string' ? Date.parse(<string>timestamp) : timestamp;
  102. const tx = getTx(transactionId, txMap);
  103. const _sender = getNode(sender, nodeMap);
  104. const _receiver = getNode(receiver, nodeMap);
  105. const _owner = getNode(owner, nodeMap);
  106. const _connectionTo = getNode(connectionTo, nodeMap);
  107. if (eventType === EventType.TEST_START) {
  108. Object.assign(localTestConfig, testConfig);
  109. expectedEndTime = startTime + localTestConfig.duration;
  110. continue;
  111. }
  112. if (nTimestamp < expectedEndTime) {
  113. switch (eventType) {
  114. case EventType.TRANSACTION_START:
  115. tx.txData = {
  116. from: _sender.pod.address,
  117. to: _receiver.pod.address,
  118. };
  119. tx.transaction.lifetime.start = nTimestamp;
  120. break;
  121. case EventType.TRANSACTION_END:
  122. tx.transaction.lifetime.end = nTimestamp;
  123. _sender.counts.sender += 1;
  124. break;
  125. case EventType.REQUEST_VALIDATION_START:
  126. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  127. _owner.counts.currentValidator += 1;
  128. tx.currentValidators[_owner.pod.address].validation.lifetime.start = nTimestamp;
  129. tx.currentValidators[_owner.pod.address].validation.requestValidation.start = nTimestamp;
  130. break;
  131. case EventType.REQUEST_VALIDATION_END:
  132. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  133. tx.currentValidators[_owner.pod.address].validation.lifetime.end = nTimestamp;
  134. tx.currentValidators[_owner.pod.address].validation.requestValidation.end = nTimestamp;
  135. break;
  136. case EventType.CONNECT_TO_VALIDATOR_START:
  137. doesValidatorExist(_connectionTo.pod.address, ValidatorType.CURRENT, tx);
  138. tx.currentValidators[_connectionTo.pod.address].connection.start = nTimestamp;
  139. break;
  140. case EventType.CONNECT_TO_VALIDATOR_END:
  141. doesValidatorExist(_connectionTo.pod.address, ValidatorType.CURRENT, tx);
  142. tx.currentValidators[_connectionTo.pod.address].connection.end = nTimestamp;
  143. break;
  144. case EventType.CONNECT_TO_PREVIOUS_VALIDATOR_START:
  145. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx, () => {
  146. doesValidatorExist(_connectionTo.pod.address, ValidatorType.PREVIOUS, tx, () => {
  147. tempDoesValidatorExist(_owner.pod.address, ValidatorType.PREVIOUS, _connectionTo.pod.address, tx);
  148. _connectionTo.counts.previousValidator += 1;
  149. tx.previousValidators[_connectionTo.pod.address].connection[_owner.pod.address].start = nTimestamp;
  150. });
  151. });
  152. break;
  153. case EventType.CONNECT_TO_PREVIOUS_VALIDATOR_END:
  154. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx, () => {
  155. doesValidatorExist(_connectionTo.pod.address, ValidatorType.PREVIOUS, tx, () => {
  156. tempDoesValidatorExist(_owner.pod.address, ValidatorType.PREVIOUS, _connectionTo.pod.address, tx);
  157. tx.previousValidators[_connectionTo.pod.address].connection[_owner.pod.address].end = nTimestamp;
  158. });
  159. });
  160. break;
  161. case EventType.GENERATE_SIGNATURE_START:
  162. tx.transaction.generateSignature.start = nTimestamp;
  163. break;
  164. case EventType.GENERATE_SIGNATURE_END:
  165. tx.transaction.generateSignature.end = nTimestamp;
  166. break;
  167. case EventType.VALIDATE_SIGNATURE_START:
  168. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  169. tx.currentValidators[_owner.pod.address].validation.validateSignature.start = nTimestamp;
  170. break;
  171. case EventType.VALIDATE_SIGNATURE_END:
  172. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  173. tx.currentValidators[_owner.pod.address].validation.validateSignature.end = nTimestamp;
  174. break;
  175. case EventType.VALIDATE_LEDGER_START:
  176. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  177. tx.currentValidators[_owner.pod.address].validation.validateLedger.start = nTimestamp;
  178. break;
  179. case EventType.VALIDATE_LEDGER_END:
  180. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  181. tx.currentValidators[_owner.pod.address].validation.validateLedger.end = nTimestamp;
  182. break;
  183. case EventType.GET_ENTRY_FROM_LEDGER_START:
  184. doesValidatorExist(_owner.pod.address, ValidatorType.PREVIOUS, tx);
  185. tx.previousValidators[_owner.pod.address].validation.getEntryFromLedger.start = nTimestamp;
  186. break;
  187. case EventType.GET_ENTRY_FROM_LEDGER_END:
  188. doesValidatorExist(_owner.pod.address, ValidatorType.PREVIOUS, tx);
  189. tx.previousValidators[_owner.pod.address].validation.getEntryFromLedger.end = nTimestamp;
  190. break;
  191. case EventType.GENERATE_TRANSACTION_HASH_START:
  192. try {
  193. if (_owner.pod.address === _sender.pod.address) {
  194. tx.transaction.generateHash.start = nTimestamp;
  195. }
  196. else {
  197. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  198. tx.currentValidators[_owner.pod.address].validation.generateHash.start = nTimestamp;
  199. }
  200. } catch (error) {
  201. console.dir(result);
  202. console.log(error);
  203. }
  204. break;
  205. case EventType.GENERATE_TRANSACTION_HASH_END:
  206. if (_owner.pod.address === _sender.pod.address) {
  207. tx.transaction.generateHash.end = nTimestamp;
  208. }
  209. else {
  210. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  211. tx.currentValidators[_owner.pod.address].validation.generateHash.end = nTimestamp;
  212. }
  213. break;
  214. case EventType.WRITE_TO_MY_LEDGER_START:
  215. tx.transaction.writeToMyLedger.start = nTimestamp;
  216. break;
  217. case EventType.WRITE_TO_MY_LEDGER_END:
  218. tx.transaction.writeToMyLedger.end = nTimestamp;
  219. break;
  220. case EventType.WRITE_TO_WITNESS_LEDGER_START:
  221. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  222. tx.currentValidators[_owner.pod.address].validation.writeToWitnessLedger.start = nTimestamp;
  223. break;
  224. case EventType.WRITE_TO_WITNESS_LEDGER_END:
  225. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx);
  226. tx.currentValidators[_owner.pod.address].validation.writeToWitnessLedger.end = nTimestamp;
  227. break;
  228. case EventType.CONNECT_TO_SNAPSHOT_NODE_START:
  229. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx, () => {
  230. doesValidatorExist(_connectionTo.pod.address, ValidatorType.SNAPSHOT, tx, () => {
  231. tempDoesValidatorExist(_owner.pod.address, ValidatorType.SNAPSHOT, _connectionTo.pod.address, tx);
  232. _connectionTo.counts.snapshotValidator += 1;
  233. tx.snapshotValidators[_connectionTo.pod.address].connection[_owner.pod.address].start = nTimestamp;
  234. });
  235. });
  236. break;
  237. case EventType.CONNECT_TO_SNAPSHOT_NODE_END:
  238. doesValidatorExist(_owner.pod.address, ValidatorType.CURRENT, tx, () => {
  239. doesValidatorExist(_connectionTo.pod.address, ValidatorType.SNAPSHOT, tx, () => {
  240. tempDoesValidatorExist(_owner.pod.address, ValidatorType.SNAPSHOT, _connectionTo.pod.address, tx);
  241. tx.snapshotValidators[_connectionTo.pod.address].connection[_owner.pod.address].end = nTimestamp;
  242. });
  243. });
  244. break;
  245. default:
  246. break;
  247. }
  248. }
  249. if (i === results.length - 1) {
  250. const keys = Object.keys(txMap);
  251. const randomNumber = Math.floor(Math.random() * (keys.length));
  252. const key = keys[randomNumber];
  253. const randomTx = txMap[key];
  254. const entries = (<any>Object).entries(txMap);
  255. setAllDiffs(entries);
  256. populateNodePerformance(txMap, nodeMap, (newTxMap, newPodMap) => {
  257. calculateNodePerformance(newTxMap, newPodMap);
  258. });
  259. checkTestIntegrity(results, txMap, nodeMap, localTestConfig, startTime, endTime, (result) => {
  260. if (result) {
  261. getResults(txMap, nodeMap, localTestConfig, printResults);
  262. }
  263. else {
  264. console.log('Log failed integrity check. Add messages.');
  265. }
  266. });
  267. console.log(key);
  268. console.log(util.inspect(randomTx, false, null));
  269. // console.dir(nodeMap);
  270. }
  271. }
  272. };
  273.  
  274. const populateNodePerformance = (txMap: ITxMap, nodeMap: INodeMap, callback: (txMap: ITxMap, nodeMap: INodeMap) => void) => {
  275. const keys = Object.keys(txMap);
  276. for (let i = 0; i < keys.length; i += 1) {
  277. const key = keys[i];
  278. const tx = txMap[key];
  279. const cvKeys = Object.keys(tx.currentValidators);
  280. for (let k = 0; k < cvKeys.length; k += 1) {
  281. const cvKey = cvKeys[k];
  282. const node = getNodeByAddress(cvKey, nodeMap);
  283. if (!node.transactions.hasOwnProperty(key)) {
  284. node.transactions[key] = {
  285. currentValidator: false,
  286. previousValidator: false,
  287. };
  288. }
  289. node.transactions[key].currentValidator = true;
  290. }
  291. const pvKeys = Object.keys(tx.previousValidators);
  292. for (let j = 0; j < pvKeys.length; j += 1) {
  293. const pvKey = pvKeys[j];
  294. const node = getNodeByAddress(pvKey, nodeMap);
  295. if (!node.transactions.hasOwnProperty(key)) {
  296. node.transactions[key] = {
  297. currentValidator: false,
  298. previousValidator: false,
  299. };
  300. }
  301. node.transactions[key].previousValidator = true;
  302. }
  303. }
  304. callback(txMap, nodeMap);
  305. };
  306.  
  307. const calculateNodePerformance = (txMap: ITxMap, nodeMap: INodeMap): void => {
  308. const keys = Object.keys(nodeMap);
  309. for (let i = 0; i < keys.length; i += 1) {
  310. const key = keys[i];
  311. const node = nodeMap[key];
  312. const txKeys = Object.keys(node.transactions);
  313. for (let k = 0; k < txKeys.length; k += 1) {
  314. const txKey = txKeys[k];
  315. const tx = txMap[txKey];
  316. const { txTimes, validationTimes, connectionTimes } = node.performance;
  317.  
  318. const txDiff = tx.transaction.lifetime.diff;
  319. txTimes.count += 1;
  320. if (txDiff !== undefined) {
  321. txTimes.total += txDiff;
  322. txDiff > txTimes.longest && (txTimes.longest = txDiff);
  323. txDiff < txTimes.shortest && (txTimes.shortest = txDiff);
  324. }
  325. else {
  326. txTimes.undef += 1;
  327. }
  328.  
  329. if (node.transactions[txKey].currentValidator) {
  330. const cv = tx.currentValidators[key];
  331. const cvValidDiff = cv.validation.lifetime.diff;
  332. validationTimes.count += 1;
  333. if (cvValidDiff !== undefined) {
  334. validationTimes.currentValidators.count += 1;
  335. validationTimes.total += cvValidDiff;
  336. validationTimes.currentValidators.total += cvValidDiff;
  337. cvValidDiff > validationTimes.currentValidators.longest && (validationTimes.currentValidators.longest = cvValidDiff);
  338. cvValidDiff < validationTimes.currentValidators.shortest && (validationTimes.currentValidators.shortest = cvValidDiff);
  339. }
  340. else {
  341. validationTimes.undef += 1;
  342. }
  343.  
  344. const cvConnDiff = cv.connection.diff;
  345. connectionTimes.count += 1;
  346. if (cvConnDiff !== undefined) {
  347. connectionTimes.currentValidators.count += 1;
  348. connectionTimes.total += cvConnDiff;
  349. connectionTimes.currentValidators.total += cvConnDiff;
  350. cvConnDiff > connectionTimes.currentValidators.longest && (connectionTimes.currentValidators.longest = cvConnDiff);
  351. cvConnDiff < connectionTimes.currentValidators.shortest && (connectionTimes.currentValidators.shortest = cvConnDiff);
  352. }
  353. else {
  354. connectionTimes.undef += 1;
  355. }
  356. }
  357. if (node.transactions[txKey].previousValidator) {
  358. const pv = tx.previousValidators[key];
  359. const pvValidDiff = pv.validation.lifetime.diff;
  360. validationTimes.count += 1;
  361. if (pvValidDiff !== undefined) {
  362. validationTimes.previousValidators.count += 1;
  363. validationTimes.total += pvValidDiff;
  364. validationTimes.previousValidators.total += pvValidDiff;
  365. pvValidDiff > validationTimes.previousValidators.longest && (validationTimes.previousValidators.longest = pvValidDiff);
  366. pvValidDiff < validationTimes.previousValidators.shortest && (validationTimes.previousValidators.shortest = pvValidDiff);
  367. }
  368. else {
  369. validationTimes.undef += 1;
  370. }
  371.  
  372. const pvConnKeys = Object.keys(pv.connection);
  373. for (let j = 0; j < pvConnKeys.length; j += 1) {
  374. const pvcKey = pvConnKeys[j];
  375. const pvc = pv.connection[pvcKey];
  376. const pvcDiff = pvc.diff;
  377. connectionTimes.count += 1;
  378. if (pvcDiff !== undefined) {
  379. connectionTimes.previousValidators.count += 1;
  380. connectionTimes.total += pvcDiff;
  381. connectionTimes.previousValidators.total += pvcDiff;
  382. pvcDiff > connectionTimes.previousValidators.longest && (connectionTimes.previousValidators.longest = pvcDiff);
  383. pvcDiff < connectionTimes.previousValidators.shortest && (connectionTimes.previousValidators.shortest = pvcDiff);
  384. }
  385. else {
  386. connectionTimes.undef += 1;
  387. }
  388. }
  389. }
  390. }
  391. }
  392. };
  393.  
  394. const setAllDiffs = (entries: [string, ITx][]) => {
  395. const readProp = (prop: any) => {
  396. const keys = Object.keys(prop);
  397. for (let i = 0; i < keys.length; i += 1) {
  398. const key = keys[i];
  399. const value = prop[key];
  400. if (value) {
  401. if (value.constructor.name === 'EventTimestamp') {
  402. if (value.end >= value.start) {
  403. value.diff = value.end - value.start;
  404. }
  405. }
  406. else {
  407. if (typeof value === 'object') {
  408. readProp(value);
  409. }
  410. }
  411. }
  412. }
  413. };
  414. for (const [, tx] of entries) {
  415. readProp(tx);
  416. }
  417. };
  418.  
  419. const getNode = (pod: Pod | undefined, nodeMap: INodeMap): INode => {
  420. let node = {} as INode;
  421. if (pod !== undefined) {
  422. if (!nodeMap.hasOwnProperty(pod.address)) {
  423. info('[getNode] Pod does not exist in nodeMap. Adding...');
  424. node = nodeMap[pod.address] = {
  425. pod,
  426. location: '',
  427. counts: {
  428. sender: 0,
  429. receiver: 0,
  430. currentValidator: 0,
  431. previousValidator: 0,
  432. },
  433. transactions: {},
  434. performance: {
  435. txTimes: new SubCounts(),
  436. validationTimes: new Counts(),
  437. connectionTimes: new Counts(),
  438. },
  439. };
  440. }
  441. else {
  442. info('[getNode] Pod already exists in nodeMap.');
  443. node = nodeMap[pod.address];
  444. }
  445. }
  446. else {
  447. console.log('Pod was undefined.');
  448. }
  449. return node;
  450. };
  451.  
  452. const getNodeByAddress = (address: string, nodeMap: INodeMap): INode => {
  453. let node = {} as INode;
  454. if (!nodeMap.hasOwnProperty(address)) {
  455. info(`[getNodeByAddress] Pod with address: ${address} does not exist in nodeMap.`);
  456. }
  457. else {
  458. info('[getNodeByAddress] Pod already exists in nodeMap.');
  459. node = nodeMap[address];
  460. }
  461. return node;
  462. };
  463.  
  464. const getTx = (transactionId: string, txMap: ITxMap): ITx => {
  465. let _tx = {} as ITx;
  466. if (!txMap.hasOwnProperty(transactionId)) {
  467. _tx = txMap[transactionId] = {
  468. txData: {
  469. from: '',
  470. to: '',
  471. },
  472. transaction: {
  473. lifetime: new EventTimestamp(0, 0),
  474. generateSignature: new EventTimestamp(0, 0),
  475. writeToMyLedger: new EventTimestamp(0, 0),
  476. generateHash: new EventTimestamp(0, 0),
  477. },
  478. currentValidators: {},
  479. previousValidators: {},
  480. snapshotValidators: {},
  481. };
  482. }
  483. else {
  484. _tx = txMap[transactionId];
  485. }
  486. return _tx;
  487. };
  488.  
  489. const tempDoesValidatorExist = (currentValidatorAddress: string, type: ValidatorType, validatorAddress: string, tx: ITx): void => {
  490. if (type === ValidatorType.PREVIOUS) {
  491. if (!tx.previousValidators[validatorAddress].connection.hasOwnProperty(currentValidatorAddress)) {
  492. tx.previousValidators[validatorAddress].connection[currentValidatorAddress] = new EventTimestamp(0, 0);
  493. }
  494. }
  495. if (type === ValidatorType.SNAPSHOT) {
  496. if (!tx.snapshotValidators[validatorAddress].connection.hasOwnProperty(currentValidatorAddress)) {
  497. tx.snapshotValidators[validatorAddress].connection[currentValidatorAddress] = new EventTimestamp(0, 0);
  498. }
  499. }
  500. };
  501.  
  502. const doesValidatorExist = (address: string, type: ValidatorType, tx: ITx, callback: () => void = () => {}): void => {
  503. if (type === ValidatorType.CURRENT) {
  504. if (!tx.currentValidators.hasOwnProperty(address)) {
  505. addValidatorToTx(address, type, tx, callback);
  506. }
  507. else {
  508. callback();
  509. }
  510. }
  511. if (type === ValidatorType.PREVIOUS) {
  512. if (!tx.previousValidators.hasOwnProperty(address)) {
  513. addValidatorToTx(address, type, tx, callback);
  514. }
  515. else {
  516. callback();
  517. }
  518. }
  519. if (type === ValidatorType.SNAPSHOT) {
  520. if (!tx.snapshotValidators.hasOwnProperty(address)) {
  521. addValidatorToTx(address, type, tx, callback);
  522. }
  523. else {
  524. callback();
  525. }
  526. }
  527. };
  528.  
  529. const addValidatorToTx = (address: string, type: ValidatorType, tx: ITx, callback: () => void = () => { }): ITx => {
  530. const currentValidatorObj = {
  531. validation: {
  532. lifetime: new EventTimestamp(0, 0),
  533. requestValidation: new EventTimestamp(0, 0),
  534. validateSignature: new EventTimestamp(0, 0),
  535. validateLedger: new EventTimestamp(0, 0),
  536. generateHash: new EventTimestamp(0, 0),
  537. writeToWitnessLedger: new EventTimestamp(0, 0),
  538. },
  539. connection: new EventTimestamp(0, 0),
  540. };
  541. const previousValidatorObj = {
  542. validation: {
  543. lifetime: new EventTimestamp(0, 0),
  544. getEntryFromLedger: new EventTimestamp(0, 0),
  545. },
  546. connection: {},
  547. };
  548. const snapshotValidatorObj = {
  549. validation: {
  550. generateSnapshot: new EventTimestamp(0, 0),
  551. },
  552. connection: {},
  553. };
  554.  
  555. if (type === ValidatorType.CURRENT) {
  556. tx.currentValidators[address] = currentValidatorObj;
  557. }
  558.  
  559. if (type === ValidatorType.PREVIOUS) {
  560. tx.previousValidators[address] = previousValidatorObj;
  561. }
  562.  
  563. if (type === ValidatorType.SNAPSHOT) {
  564. tx.snapshotValidators[address] = snapshotValidatorObj;
  565. }
  566. callback();
  567. return tx;
  568. };
  569.  
  570. const getResults = (txMap: ITxMap, nodeMap: INodeMap, testConfig: TestConfig, printResults: boolean): LogResults | void => {
  571. const results = new LogResults(txMap, nodeMap, testConfig);
  572. results.numTxs = Object.keys(txMap).length;
  573.  
  574. const regularPodCount = Object.keys(nodeMap).filter(key => nodeMap[key].pod.podType === 0).length;
  575. const partnerPodCount = Object.keys(nodeMap).filter(key => nodeMap[key].pod.podType === 1).length;
  576.  
  577. results.numPods = {
  578. total: Object.keys(nodeMap).length,
  579. regular: regularPodCount,
  580. partner: partnerPodCount,
  581. sender: testConfig.numSenders,
  582. };
  583.  
  584. results.duration = endTime - startTime;
  585. results.setTimes();
  586.  
  587. globalResults = results;
  588. fs.writeFileSync('results.json', JSON.stringify(results, null, 2));
  589. if (printResults) {
  590. results.printResults();
  591. }
  592. else {
  593. return results;
  594. }
  595. };
  596.  
  597. export { getGlobalResults, LogType, parseResults };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!