() {
57 | @Override
58 | protected void initChannel(SocketChannel socketChannel) throws Exception {
59 | ChannelPipeline p = socketChannel.pipeline();
60 | p.addLast(new IdleStateHandler(0, 0, CHANNEL_TIMEOUT),
61 | new ObjectEncoder(),
62 | new ObjectDecoder(MAX_MESSAGE_SIZE, ClassResolvers.cacheDisabled(null)),
63 | new SocketServerHandler(localStore));
64 | }
65 | });
66 |
67 | Log.log(Level.INFO, "Starting socket server on port " + this.port);
68 | b.bind(port).sync().channel().closeFuture().sync();
69 | } catch (InterruptedException e) {
70 | Log.log(Level.INFO, "Socket server was interrupted, shutting down...");
71 | } catch (Exception ex) {
72 | Log.log(Level.SEVERE, "Exception in socket server", ex);
73 | } finally {
74 | bossGroup.shutdownGracefully();
75 | workerGroup.shutdownGracefully();
76 | }
77 | }
78 |
79 | @Override
80 | public void run() {
81 | this.initServer();
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/sockets/SocketServerHandler.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.sockets;
2 |
3 | import io.netty.channel.ChannelHandlerContext;
4 | import io.netty.channel.ChannelInboundHandlerAdapter;
5 | import io.netty.handler.timeout.IdleState;
6 | import io.netty.handler.timeout.IdleStateEvent;
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.message.Message;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Log;
10 |
11 | import java.util.logging.Level;
12 |
13 | /**
14 | * Handler for socket server.
15 | */
16 | public class SocketServerHandler extends ChannelInboundHandlerAdapter {
17 |
18 | private LocalStore localStore;
19 |
20 | /**
21 | * Constructor.
22 | * @param localStore - the localstor of the node
23 | */
24 | public SocketServerHandler(LocalStore localStore) {
25 | this.localStore = localStore;
26 | }
27 |
28 | @Override
29 | public void channelRead(ChannelHandlerContext ctx, Object msg) {
30 | if (msg instanceof Message) {
31 | ((Message) msg).handle(localStore);
32 | } else {
33 | Log.log(Level.SEVERE, "Invalid message, not a message instance");
34 | }
35 | }
36 |
37 | @Override
38 | public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
39 | Log.log(Level.SEVERE, "Node " + localStore.getOwnNode().getId() + " Server: socket error", cause);
40 | ctx.close();
41 | }
42 |
43 | @Override
44 | public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
45 | if (evt instanceof IdleStateEvent) {
46 | IdleStateEvent e = (IdleStateEvent) evt;
47 | if (e.state() == IdleState.ALL_IDLE) {
48 | Log.log(Level.FINE, "Node " + localStore.getOwnNode().getId() + " Server: detected idle channel, closing connection!");
49 | ctx.close();
50 | }
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/utils/Log.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.utils;
2 |
3 | import java.util.logging.ConsoleHandler;
4 | import java.util.logging.Handler;
5 | import java.util.logging.Level;
6 | import java.util.logging.Logger;
7 |
8 | /**
9 | * Class for logging functions.
10 | */
11 | public final class Log {
12 | public static final Level LEVEL = Level.INFO;
13 | public static final String FORMAT = "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$-6s %3$s %5$s%6$s%n";
14 | public static final String DEBUG_FORMAT = "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$-6s %2$s %5$s%6$s%n";
15 |
16 | public static final Logger PARENT_LOGGER = Logger.getLogger(Log.class.getName()).getParent();
17 | public static final Logger DEBUG_LOGGER = Logger.getLogger("DEBUG");
18 |
19 | private Log() {
20 | throw new UnsupportedOperationException();
21 | }
22 |
23 | static {
24 | //Set the level and the format string.
25 | PARENT_LOGGER.setLevel(LEVEL);
26 |
27 | LogFormatter formatter = new LogFormatter(FORMAT);
28 | for (Handler handler : PARENT_LOGGER.getHandlers()) {
29 | if (handler instanceof ConsoleHandler) {
30 | handler.setFormatter(formatter);
31 | handler.setLevel(LEVEL);
32 | }
33 | }
34 |
35 | //Create debug console handler
36 | ConsoleHandler debugHandler = new ConsoleHandler();
37 | debugHandler.setLevel(Level.ALL);
38 | debugHandler.setFormatter(new LogFormatter(DEBUG_FORMAT));
39 |
40 | //Setup debug logger
41 | DEBUG_LOGGER.setUseParentHandlers(false);
42 | DEBUG_LOGGER.addHandler(debugHandler);
43 | DEBUG_LOGGER.setLevel(LEVEL);
44 | }
45 |
46 | /**
47 | * Change the log level.
48 | * @param level - the level to change to.
49 | */
50 | public static void setLogLevel(Level level) {
51 | PARENT_LOGGER.setLevel(level);
52 | }
53 |
54 | /**
55 | * Get the current log level.
56 | * @return - the current log level
57 | */
58 | public static Level getLogLevel() {
59 | return PARENT_LOGGER.getLevel();
60 | }
61 |
62 | /**
63 | * Handle logging of an exception.
64 | * @param level - level of the exception
65 | * @param str - message for the logs
66 | * @param throwable - the object of the exception
67 | */
68 | public static void log(Level level, String str, Throwable throwable) {
69 | // By default
70 | Logger.getLogger(getCallerClassName()).log(level, str, throwable);
71 | }
72 |
73 | /**
74 | * Logs the given message.
75 | * @param level - level to log at
76 | * @param str - message to log
77 | */
78 | public static void log(Level level, String str) {
79 | Logger.getLogger(getCallerClassName()).log(level, str);
80 | }
81 |
82 | /**
83 | * Logs the given message for the given node id.
84 | * @param level - level to log at
85 | * @param str - message to log
86 | * @param nodeId - the id of the node
87 | */
88 | public static void log(Level level, String str, int nodeId) {
89 | Logger.getLogger(getCallerClassName()).log(level, "[" + nodeId + "] " + str);
90 | }
91 |
92 | /**
93 | * Logs the given debug message.
94 | * @param msg - the message
95 | * @param params - the parameters
96 | */
97 | public static void debug(String msg, Object... params) {
98 | StackTraceElement ste = getCallerStackTrace(3);
99 | if (ste == null) {
100 | DEBUG_LOGGER.logp(Level.INFO, null, null, msg, params);
101 | } else {
102 | String className = ste.getClassName();
103 | className = className.substring(className.lastIndexOf('.') + 1);
104 | String sourceMethod = ste.getMethodName() + ":" + ste.getLineNumber();
105 | DEBUG_LOGGER.logp(Level.INFO, className, sourceMethod, msg, params);
106 | }
107 | }
108 |
109 | /**
110 | * Get the name of the last class that added to the stack.
111 | * @return class name
112 | */
113 | private static String getCallerClassName() {
114 | StackTraceElement ste = getCallerStackTrace(4);
115 | if (ste == null) return null;
116 | String className = ste.getClassName();
117 | return className.substring(className.lastIndexOf('.') + 1);
118 | }
119 |
120 | /**
121 | * Determines the stack trace element of the caller.
122 | * @return - the stack trace element of the caller
123 | */
124 | private static StackTraceElement getCallerStackTrace(int start) {
125 | StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
126 | for (int i = start; i < stackTraceElements.length; i++) {
127 | StackTraceElement ste = stackTraceElements[i];
128 | if (ste.getClassName().indexOf("java.lang.Thread") != 0) {
129 | return ste;
130 | }
131 | }
132 | return null;
133 | }
134 | }
135 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/utils/LogFormatter.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.utils;
2 |
3 | import java.io.PrintWriter;
4 | import java.io.StringWriter;
5 | import java.util.Date;
6 | import java.util.logging.Formatter;
7 | import java.util.logging.LogRecord;
8 |
9 | /**
10 | * Formatter for the log. This class is mostly a clone of SimpleFormatter but with a few small adjustments.
11 | */
12 | public class LogFormatter extends Formatter {
13 | private final String format;
14 | private final Date dat = new Date();
15 |
16 | /**
17 | * Creates a new log formatter with the given format.
18 | *
19 | * %1 = date
20 | * %2 = source class
21 | * %3 = logger name
22 | * %4 = level
23 | * %5 = message
24 | * %6 = exception
25 | *
26 | * @param format - the format string
27 | */
28 | public LogFormatter(String format) {
29 | this.format = format;
30 | }
31 |
32 | @Override
33 | public synchronized String format(LogRecord record) {
34 | dat.setTime(record.getMillis());
35 | String source;
36 | if (record.getSourceClassName() != null) {
37 | source = record.getSourceClassName();
38 | if (record.getSourceMethodName() != null) {
39 | source += " " + record.getSourceMethodName();
40 | }
41 | } else {
42 | source = record.getLoggerName();
43 | }
44 | String message = formatMessage(record);
45 | String throwable;
46 | if (record.getThrown() != null) {
47 | StringWriter sw = new StringWriter();
48 | try (PrintWriter pw = new PrintWriter(sw)) {
49 | pw.println();
50 | record.getThrown().printStackTrace(pw);
51 | }
52 | throwable = sw.toString();
53 | } else {
54 | throwable = "";
55 | }
56 |
57 | return String.format(format, dat, source, record.getLoggerName(), record.getLevel().getLocalizedName(), message, throwable);
58 | }
59 |
60 | }
61 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/utils/Utils.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.utils;
2 |
3 | import java.io.UnsupportedEncodingException;
4 | import java.util.Base64;
5 | import java.util.logging.Level;
6 |
7 | /**
8 | * Class for helper functions.
9 | */
10 | public final class Utils {
11 | private static final char[] HEX = {
12 | '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
13 | };
14 |
15 | private Utils() {
16 | throw new UnsupportedOperationException();
17 | }
18 |
19 | /**
20 | * Convert a integer into a byte array.
21 | * @param number - the number to convert
22 | * @return byte array
23 | */
24 | public static byte[] intToByteArray(int number) {
25 | return new byte[] {
26 | (byte) (number >>> 24),
27 | (byte) (number >>> 16),
28 | (byte) (number >>> 8),
29 | (byte) number
30 | };
31 | }
32 |
33 | /**
34 | * Convert a long into a byte array.
35 | * @param number - the number to convert
36 | * @return byte array
37 | */
38 | public static byte[] longToByteArray(long number) {
39 | return new byte[] {
40 | (byte) (number >> 56),
41 | (byte) (number >> 48),
42 | (byte) (number >> 40),
43 | (byte) (number >> 32),
44 | (byte) (number >> 24),
45 | (byte) (number >> 16),
46 | (byte) (number >> 8),
47 | (byte) number
48 | };
49 | }
50 |
51 | /**
52 | * Converts a byte array into a hexadecimal string.
53 | * @param bytes - array of bytes to be converted
54 | * @return hexadecimal string
55 | */
56 | public static String bytesToHexString(byte[] bytes) {
57 | StringBuilder buffer = new StringBuilder(bytes.length * 2);
58 | for (byte b : bytes) {
59 | buffer.append(HEX[(b >> 4) & 0xF]);
60 | buffer.append(HEX[b & 0xF]);
61 | }
62 | return buffer.toString();
63 | }
64 |
65 | /**
66 | * Converts a hexadecimal String to a byte array.
67 | * @param hex - the hexadecimal string
68 | * @return the byte array
69 | */
70 | public static byte[] hexStringToBytes(String hex) {
71 | int strLen = hex.length();
72 | if (strLen % 2 != 0) throw new IllegalArgumentException("Length must be even!");
73 |
74 | byte[] bytes = new byte[strLen / 2];
75 | for (int i = 0; i < strLen; i += 2) {
76 | int high = hexToBin(hex.charAt(i));
77 | int low = hexToBin(hex.charAt(i + 1));
78 | bytes[i / 2] = (byte) ((high << 4) + low);
79 | }
80 |
81 | return bytes;
82 | }
83 |
84 | /**
85 | * @param ch - the hex character to convert
86 | * @return the binary value of the given hex character
87 | */
88 | private static int hexToBin(char ch) {
89 | if ('0' <= ch && ch <= '9') {
90 | return ch - '0';
91 | }
92 | if ('A' <= ch && ch <= 'F') {
93 | return ch - 'A' + 10;
94 | }
95 | if ('a' <= ch && ch <= 'f') {
96 | return ch - 'a' + 10;
97 | }
98 | throw new IllegalArgumentException("'" + ch + "' is not a hexadecimal character!");
99 | }
100 |
101 | /**
102 | * Convert a base 64 string to a byte array.
103 | * @param data - The base 64 string to convert
104 | * @return - The resulting byte array, or an empty one if the conversion fails
105 | */
106 | public static byte[] base64StringToBytes(String data) {
107 | try {
108 | return Base64.getDecoder().decode(data.getBytes("UTF-8"));
109 | } catch (UnsupportedEncodingException e) {
110 | Log.log(Level.SEVERE, "This encoding should always be present", e);
111 | return new byte[0];
112 | }
113 | }
114 |
115 | /**
116 | * Convert a byte array to a base 64 string.
117 | * @param bytes - The bytes to convert
118 | * @return - The resulting base 64 string, or an empty one if the conversion fails
119 | */
120 | public static String bytesToBas64String(byte[] bytes) {
121 | return Base64.getEncoder().encodeToString(bytes);
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/validation/ProofValidationException.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.validation;
2 |
3 | /**
4 | * Validation exception for proofs.
5 | */
6 | public class ProofValidationException extends ValidationException {
7 | private static final long serialVersionUID = 1L;
8 |
9 | /**
10 | * @param reason - the reason
11 | */
12 | public ProofValidationException(String reason) {
13 | super(reason);
14 | }
15 |
16 | /**
17 | * @param reason - the reason
18 | * @param cause - the validation exception that caused this one
19 | */
20 | public ProofValidationException(String reason, ValidationException cause) {
21 | super(reason, cause);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/nl/tudelft/blockchain/scaleoutdistributedledger/validation/ValidationException.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.validation;
2 |
3 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Transaction;
4 |
5 | /**
6 | * Exception for representing validation going wrong.
7 | */
8 | public class ValidationException extends RuntimeException {
9 | private static final long serialVersionUID = 1L;
10 |
11 | /**
12 | * @param reason - the reason
13 | */
14 | public ValidationException(String reason) {
15 | super(reason);
16 | }
17 |
18 | /**
19 | * @param reason - the reason
20 | * @param cause - the validation exception that caused this one
21 | */
22 | public ValidationException(String reason, ValidationException cause) {
23 | super(reason, cause);
24 | }
25 |
26 | /**
27 | * Creates a validation exception with the following message.
28 | * Transaction [transaction] is invalid: [reason]
29 | * @param transaction - the transaction
30 | * @param reason - the reason
31 | */
32 | public ValidationException(Transaction transaction, String reason) {
33 | super("Transaction " + transaction + " is invalid: " + reason);
34 | }
35 |
36 | /**
37 | * Creates a validation exception with the following message.
38 | * Transaction [transaction] is invalid: [reason]
39 | * @param transaction - the transaction
40 | * @param reason - the reason
41 | * @param cause - the validation exception that caused this one
42 | */
43 | public ValidationException(Transaction transaction, String reason, ValidationException cause) {
44 | super("Transaction " + transaction + " is invalid: " + reason, cause);
45 | }
46 |
47 | @Override
48 | public String getMessage() {
49 | if (this.getCause() != null) {
50 | return super.getMessage() + " caused by " + this.getCause().getMessage();
51 | } else {
52 | return super.getMessage();
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/main/resources/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blockchain-lab/ScaleOutDistributedLedger/1bb03b7eeb20b609033cc5a7797df654cb8ce061/src/main/resources/.gitignore
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/ApplicationTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger;
2 |
3 | import nl.tudelft.blockchain.scaleoutdistributedledger.mocks.TendermintChainMock;
4 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
5 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.mainchain.MainChain;
6 | import nl.tudelft.blockchain.scaleoutdistributedledger.simulation.CancellableInfiniteRunnable;
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.simulation.transactionpattern.ITransactionPattern;
8 | import org.junit.Before;
9 | import org.junit.Test;
10 |
11 | import static org.junit.Assert.assertEquals;
12 | import static org.mockito.Mockito.*;
13 |
14 | /**
15 | * Class to test {@link Application}.
16 | */
17 | public class ApplicationTest {
18 |
19 | private Application instance;
20 | private Thread serverMock;
21 | private TransactionSender transactionSenderMock;
22 | private LocalStore localStoreMock;
23 |
24 | /**
25 | * Setup method.
26 | */
27 | @Before
28 | public void setUp() {
29 | this.localStoreMock = mock(LocalStore.class);
30 | this.serverMock = mock(Thread.class);
31 | this.transactionSenderMock = mock(TransactionSender.class);
32 |
33 | this.instance = new Application(this.localStoreMock, this.serverMock, this.transactionSenderMock);
34 | when(this.localStoreMock.getMainChain()).thenReturn(spy(new TendermintChainMock()));
35 | when(this.localStoreMock.getOwnNode()).thenReturn(new OwnNode(0));
36 | }
37 |
38 | /**
39 | * Test for {@link Application#kill()}.
40 | */
41 | @Test
42 | public void testKill() {
43 | this.instance.kill();
44 |
45 | verify(this.transactionSenderMock, times(1)).shutdownNow();
46 | verify(this.instance.getMainChain(), times(1)).stop();
47 | }
48 |
49 | /**
50 | * Test for {@link Application#startTransacting()}.
51 | * @throws java.lang.InterruptedException - interrupted while sleeping
52 | */
53 | @Test
54 | public void testStartTransacting() throws InterruptedException {
55 | CancellableInfiniteRunnable runnableMock = this.setTransactionPattern();
56 |
57 | this.instance.startTransacting();
58 | // Wait for thread to start
59 | verify(runnableMock, timeout(2000).times(1)).run();
60 | }
61 |
62 | /**
63 | * Test for {@link Application#getMainChain()}.
64 | */
65 | @Test
66 | public void testGetMainChain() {
67 | MainChain chain = mock(MainChain.class);
68 | when(this.localStoreMock.getMainChain()).thenReturn(chain);
69 | assertEquals(chain, this.instance.getMainChain());
70 | }
71 |
72 | /**
73 | * Test for {@link Application#finishTransactionSending()}.
74 | * @throws InterruptedException - interrupted while sleeping
75 | */
76 | @Test
77 | public void testFinishTransactionSending() throws InterruptedException {
78 | this.instance.finishTransactionSending();
79 |
80 | // verify(this.transactionSenderMock, times(1)).stop();
81 | verify(this.transactionSenderMock, times(1)).waitUntilDone();
82 | }
83 |
84 | /**
85 | * Set a transaction pattern.
86 | * @return cancellable infinite runnable
87 | */
88 | private CancellableInfiniteRunnable setTransactionPattern() {
89 | ITransactionPattern transactionPatternMock = mock(ITransactionPattern.class);
90 | CancellableInfiniteRunnable runnableMock = mock(CancellableInfiniteRunnable.class);
91 | when(transactionPatternMock.getRunnable(any(LocalStore.class))).thenReturn(runnableMock);
92 | this.instance.setTransactionPattern(transactionPatternMock);
93 | return runnableMock;
94 | }
95 |
96 | }
97 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/CommunicationHelperTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger;
2 |
3 | import java.util.*;
4 |
5 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Block;
6 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Node;
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Proof;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Transaction;
10 | import nl.tudelft.blockchain.scaleoutdistributedledger.test.utils.TestHelper;
11 | import static org.junit.Assert.assertFalse;
12 | import static org.junit.Assert.assertTrue;
13 | import org.junit.Before;
14 | import org.junit.Test;
15 | import static org.mockito.Mockito.mock;
16 |
17 | /**
18 | * Class to test {@link CommunicationHelper}.
19 | */
20 | public class CommunicationHelperTest {
21 |
22 | private static int transactionId = 11;
23 |
24 | private Block genesisBlock;
25 |
26 | private OwnNode ownNode;
27 |
28 | private LocalStore localStore;
29 |
30 | private Node bobNode;
31 |
32 | private Node charlieNode;
33 |
34 | /**
35 | * Setup method.
36 | */
37 | @Before
38 | public void setUp() {
39 | // Setup ownNode
40 | this.ownNode = new OwnNode(0);
41 | this.genesisBlock = TestHelper.generateGenesis(this.ownNode, 10, 1000);
42 | Application application = mock(Application.class);
43 | this.localStore = new LocalStore(this.ownNode, application, this.genesisBlock, false);
44 | // Setup bobNode
45 | this.bobNode = new Node(1);
46 | bobNode.getChain().setGenesisBlock(this.genesisBlock);
47 | // Setup charlie
48 | this.charlieNode = new Node(2);
49 | this.charlieNode.getChain().setGenesisBlock(this.genesisBlock);
50 | }
51 |
52 | /**
53 | * Create a transaction from a genesis block.
54 | * @param sender - node sender
55 | * @param receiver - node receiver
56 | * @param amount - amount of the transaction
57 | * @param remainder - remainder of the transaction
58 | * @return
59 | */
60 | private Transaction createTransactionFromGenesis(Node sender, Node receiver, long amount, long remainder) {
61 | // Create new block for transaction
62 | List blockList = new ArrayList<>();
63 | blockList.add(new Block(sender.getChain().getLastBlock().getNumber() + 1, sender, new ArrayList<>()));
64 | sender.getChain().update(blockList, localStore);
65 | // Setup sources
66 | TreeSet sources = new TreeSet<>();
67 | sources.add(this.genesisBlock.getTransactions().get(sender.getId()));
68 | // Create transaction
69 | Transaction transaction = new Transaction(transactionId++, sender, receiver, amount, remainder, sources);
70 | Block blockOfTransaction = sender.getChain().getLastBlock();
71 | transaction.setBlockNumber(blockOfTransaction.getNumber());
72 | blockOfTransaction.addTransaction(transaction);
73 | return transaction;
74 | }
75 |
76 | /**
77 | * Test for {@link CommunicationHelper#receiveTransaction}.
78 | */
79 | @Test
80 | public void testReceiveTransaction_Valid() {
81 | // Create Transaction and Proof
82 | Transaction transaction = this.createTransactionFromGenesis(this.bobNode, this.ownNode, 100, 900);
83 | Proof proof = new Proof(transaction);
84 |
85 | assertTrue(CommunicationHelper.receiveTransaction(proof, this.localStore));
86 | assertTrue(this.localStore.getUnspent().contains(transaction));
87 | }
88 |
89 | /**
90 | * Test for {@link CommunicationHelper#receiveTransaction}.
91 | */
92 | @Test
93 | public void testReceiveTransaction_InvalidReceiver() {
94 | // Create Transaction and Proof
95 | Transaction transaction = this.createTransactionFromGenesis(this.bobNode, this.charlieNode, 100, 900);
96 | Proof proof = new Proof(transaction);
97 |
98 | assertFalse(CommunicationHelper.receiveTransaction(proof, this.localStore));
99 | }
100 |
101 | /**
102 | * Test for {@link CommunicationHelper#receiveTransaction}.
103 | */
104 | @Test
105 | public void testReceiveTransaction_InvalidAmount() {
106 | // Create Transaction and Proof
107 | Transaction transaction = this.createTransactionFromGenesis(this.bobNode, this.ownNode, 9999, 900);
108 | Proof proof = new Proof(transaction);
109 |
110 | assertFalse(CommunicationHelper.receiveTransaction(proof, this.localStore));
111 | }
112 |
113 | }
114 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/LocalStoreTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger;
2 |
3 | import static org.junit.Assert.assertEquals;
4 | import static org.mockito.Mockito.mock;
5 |
6 | import org.junit.Before;
7 | import org.junit.Test;
8 |
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Block;
10 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
11 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Transaction;
12 | import nl.tudelft.blockchain.scaleoutdistributedledger.test.utils.TestHelper;
13 |
14 | /**
15 | * Class to test {@link LocalStore}.
16 | */
17 | public class LocalStoreTest {
18 |
19 | private OwnNode ownNode;
20 |
21 | private LocalStore localStore;
22 |
23 | /**
24 | * Setup method.
25 | */
26 | @Before
27 | public void setUp() {
28 | this.ownNode = new OwnNode(0);
29 | Application application = mock(Application.class);
30 | Block genesisBlock = TestHelper.generateGenesis(ownNode, 10, 1000);
31 | this.localStore = new LocalStore(ownNode, application, genesisBlock, false);
32 | }
33 |
34 | /**
35 | * Test for {@link LocalStore#getTransactionFromNode(int, int)}.
36 | */
37 | @Test
38 | public void testGetTransactionFromNode_Valid_GenesisSender() {
39 | Transaction transaction = this.localStore.getTransactionFromNode(Transaction.GENESIS_SENDER, 0, 0);
40 | assertEquals(this.ownNode, transaction.getReceiver());
41 | }
42 |
43 | /**
44 | * Test for {@link LocalStore#getTransactionFromNode(int, int)}.
45 | */
46 | @Test(expected = IllegalStateException.class)
47 | public void testGetTransactionFromNode_Invalid_GenesisSender() {
48 | this.localStore.getTransactionFromNode(Transaction.GENESIS_SENDER, 0, 99);
49 | }
50 |
51 | /**
52 | * Test for {@link LocalStore#getTransactionFromNode(int, int)}.
53 | */
54 | @Test
55 | public void testGetTransactionFromNode_Valid_NormalSender() {
56 | Transaction transaction = this.localStore.getTransactionFromNode(0, 0, 0);
57 | assertEquals(this.ownNode, transaction.getReceiver());
58 | }
59 |
60 | /**
61 | * Test for {@link LocalStore#getTransactionFromNode(int, int)}.
62 | */
63 | @Test(expected = IllegalStateException.class)
64 | public void testGetTransactionFromNode_Invalid_Block() {
65 | this.localStore.getTransactionFromNode(0, 99, 1);
66 | }
67 |
68 | /**
69 | * Test for {@link LocalStore#getTransactionFromNode(int, int)}.
70 | */
71 | @Test(expected = IllegalStateException.class)
72 | public void testGetTransactionFromNode_Invalid_Transaction() {
73 | this.localStore.getTransactionFromNode(0, 0, 99);
74 | }
75 |
76 | }
77 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/message/MessageTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.message;
2 |
3 | import static org.mockito.Mockito.*;
4 |
5 | import org.junit.Before;
6 |
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.Application;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
10 |
11 | /**
12 | * Base class for testing messages.
13 | */
14 | public abstract class MessageTest {
15 |
16 | protected LocalStore storeSpy;
17 |
18 | protected Application appMock;
19 |
20 | /**
21 | * Creates the store and the application.
22 | */
23 | @Before
24 | public void setUp() {
25 | OwnNode ownNode = new OwnNode(0);
26 | this.appMock = mock(Application.class);
27 | this.storeSpy = spy(new LocalStore(ownNode, this.appMock, null, false));
28 | doNothing().when(this.storeSpy).updateNodes();
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/message/StartTransactingMessageTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.message;
2 |
3 | import static org.mockito.Mockito.*;
4 |
5 | import org.junit.Test;
6 |
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
8 |
9 | /**
10 | * Test class for {@link StartTransactingMessage}.
11 | */
12 | public class StartTransactingMessageTest extends MessageTest {
13 |
14 | /**
15 | * Test method for {@link StartTransactingMessage#handle(LocalStore)}.
16 | */
17 | @Test
18 | public void testHandle() {
19 | StartTransactingMessage msg = new StartTransactingMessage();
20 | msg.handle(storeSpy);
21 |
22 | //We should have started transacting.
23 | verify(appMock, times(1)).startTransacting();
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/message/StopTransactingMessageTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.message;
2 |
3 | import static org.mockito.Mockito.*;
4 |
5 | import org.junit.Test;
6 |
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
8 |
9 | /**
10 | * Test class for {@link StopTransactingMessage}.
11 | */
12 | public class StopTransactingMessageTest extends MessageTest {
13 |
14 | /**
15 | * Test method for {@link StopTransactingMessage#handle(LocalStore)}.
16 | */
17 | @Test
18 | public void testHandle() {
19 | StopTransactingMessage msg = new StopTransactingMessage();
20 | msg.handle(storeSpy);
21 |
22 | //We should have stopped transacting.
23 | verify(appMock, times(1)).stopTransacting();
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/message/TransactionPatternMessageTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.message;
2 |
3 | import static org.mockito.Mockito.*;
4 |
5 | import org.junit.Test;
6 |
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.simulation.transactionpattern.ITransactionPattern;
9 |
10 | /**
11 | * Test class for {@link TransactionPatternMessage}.
12 | */
13 | public class TransactionPatternMessageTest extends MessageTest {
14 |
15 | /**
16 | * Test method for {@link TransactionPatternMessage#handle(LocalStore)}.
17 | */
18 | @Test
19 | public void testHandle() {
20 | ITransactionPattern pattern = mock(ITransactionPattern.class);
21 | TransactionPatternMessage msg = new TransactionPatternMessage(pattern);
22 | msg.handle(this.storeSpy);
23 |
24 | // The correct transaction pattern should be set.
25 | verify(appMock, times(1)).setTransactionPattern(same(pattern));
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/BlockAbstractTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import java.security.InvalidKeyException;
4 | import java.security.NoSuchAlgorithmException;
5 | import java.security.SignatureException;
6 | import java.util.ArrayList;
7 | import static org.junit.Assert.assertEquals;
8 | import static org.junit.Assert.assertTrue;
9 | import org.junit.Before;
10 | import org.junit.Test;
11 |
12 | /**
13 | * Test for {@link BlockAbstract}.
14 | */
15 | public class BlockAbstractTest {
16 |
17 | private Ed25519Key key;
18 |
19 | private Block block;
20 |
21 | private BlockAbstract blockAbstract;
22 |
23 | /**
24 | * Setup method.
25 | * @throws java.security.SignatureException - error while signing
26 | * @throws java.security.InvalidKeyException - error while using the key
27 | * @throws java.security.NoSuchAlgorithmException - error while using Ed25519
28 | */
29 | @Before
30 | public void setUp() throws SignatureException, InvalidKeyException, NoSuchAlgorithmException {
31 | this.key = new Ed25519Key();
32 | OwnNode ownNode = new OwnNode(0);
33 | ownNode.setPublicKey(this.key.getPublicKey());
34 | ownNode.setPrivateKey(this.key.getPrivateKey());
35 | this.block = new Block(2, ownNode, new ArrayList<>());
36 | this.blockAbstract = this.block.calculateBlockAbstract();
37 | }
38 |
39 | /**
40 | * Test for {@link BlockAbstract#fromBytes()}.
41 | */
42 | @Test
43 | public void testFromBytes_Invalid() {
44 | // Invalid decoding
45 | BlockAbstract newBlockAbstract = BlockAbstract.fromBytes(new byte[0]);
46 | assertEquals(null, newBlockAbstract);
47 | }
48 |
49 | /**
50 | * Test for {@link BlockAbstract#toBytes()}.
51 | */
52 | @Test
53 | public void testToBytes_Invalid() {
54 | // Encode
55 | byte[] bytes = this.blockAbstract.toBytes();
56 | // Decode
57 | BlockAbstract newBlockAbstract = BlockAbstract.fromBytes(bytes);
58 |
59 | assertEquals(this.blockAbstract, newBlockAbstract);
60 | }
61 |
62 | /**
63 | * Test for {@link BlockAbstract#checkBlockHash}.
64 | */
65 | @Test
66 | public void testCheckBlockHash_Valid() {
67 | assertTrue(this.blockAbstract.checkBlockHash(this.block));
68 | }
69 |
70 | /**
71 | * Test for {@link BlockAbstract#checkSignature(byte[])}.
72 | */
73 | @Test
74 | public void testCheckSignature_Valid() {
75 | assertTrue(this.blockAbstract.checkSignature(this.key.getPublicKey()));
76 | }
77 |
78 | }
79 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/BlockTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import static org.junit.Assert.*;
4 | import static org.mockito.Mockito.mock;
5 |
6 | import java.security.SignatureException;
7 | import java.util.ArrayList;
8 |
9 | import org.junit.Before;
10 | import org.junit.Test;
11 |
12 | import nl.tudelft.blockchain.scaleoutdistributedledger.Application;
13 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
14 |
15 | /**
16 | * Test class for {@link Block}.
17 | */
18 | public class BlockTest {
19 |
20 | private OwnNode owner;
21 |
22 | private Block block;
23 |
24 | private Application application;
25 |
26 | private LocalStore localStore;
27 |
28 | /**
29 | * Setup method.
30 | */
31 | @Before
32 | public void setUp() {
33 | Ed25519Key keyPair = new Ed25519Key();
34 | this.owner = new OwnNode(24);
35 | this.owner.setPrivateKey(keyPair.getPrivateKey());
36 | this.owner.setPublicKey(keyPair.getPublicKey());
37 | this.block = new Block(1234, this.owner, new ArrayList<>());
38 | this.application = mock(Application.class);
39 | this.localStore = new LocalStore(this.owner, this.application, null, false);
40 | }
41 |
42 | /**
43 | * Test for {@link Block#getHash()}.
44 | */
45 | @Test
46 | public void testGetHash_Valid() {
47 | String hash = "334777d018eb8d1acd2d04a3f26b973169920d1c81937241a2b24c0cf0b9b448";
48 |
49 | assertTrue(this.block.getHash().toString().equals(hash));
50 | }
51 |
52 | /**
53 | * Test for {@link Block#getHash()}.
54 | */
55 | @Test
56 | public void testGetHash_Invalid() {
57 | String hash = "004777d018eb8d1acd2d04a3f26b973169920d1c81937241a2b24c0cf0b9b448";
58 |
59 | assertFalse(this.block.getHash().toString().equals(hash));
60 | }
61 |
62 | /**
63 | * Test for {@link Block#calculateBlockAbstract()}.
64 | * @throws java.security.SignatureException - fail to sign
65 | */
66 | @Test
67 | public void testCalculateBlockAbstract_Valid() throws SignatureException {
68 | byte[] attrInBytes = BlockAbstract.calculateBytesForSignature(this.owner.getId(), this.block.getNumber(), this.block.getHash());
69 |
70 | assertTrue(this.owner.verify(attrInBytes, this.block.calculateBlockAbstract().getSignature()));
71 | }
72 |
73 | /**
74 | * Test for {@link Block#calculateBlockAbstract()}.
75 | * @throws java.security.SignatureException - fail to sign
76 | */
77 | @Test
78 | public void testCalculateBlockAbstract_Invalid() throws SignatureException {
79 | byte[] attrInBytes = BlockAbstract.calculateBytesForSignature(this.owner.getId() + 1, this.block.getNumber(), this.block.getHash());
80 |
81 | assertFalse(this.owner.verify(attrInBytes, this.block.calculateBlockAbstract().getSignature()));
82 | }
83 |
84 | /**
85 | * Test for {@link Block#calculateBlockAbstract()}.
86 | */
87 | @Test(expected = UnsupportedOperationException.class)
88 | public void testCalculateBlockAbstract_Invalid_NotOwnNode() {
89 | Block newBlock = new Block(1234, new Node(1), new ArrayList<>());
90 | newBlock.calculateBlockAbstract();
91 | }
92 |
93 | /**
94 | * Test for {@link Block#commit(LocalStore)}.
95 | */
96 | @Test
97 | public void testCommit_Valid() {
98 | this.block.commit(this.localStore);
99 |
100 | assertEquals(this.block, this.owner.getChain().getLastCommittedBlock());
101 | }
102 |
103 | /**
104 | * Test for {@link Block#commit(LocalStore)}.
105 | */
106 | @Test(expected = IllegalStateException.class)
107 | public void testCommitTwice_Invalid() {
108 | this.block.commit(this.localStore);
109 | this.block.commit(this.localStore);
110 | }
111 |
112 | /**
113 | * Test for {@link Block#genesisCopy()}.
114 | */
115 | @Test
116 | public void testGenesisCopy_Valid() {
117 | Block geneisBlock = new Block(Block.GENESIS_BLOCK_NUMBER, this.owner, new ArrayList<>());
118 | Block newGenesisBlock = geneisBlock.genesisCopy();
119 |
120 | assertEquals(geneisBlock, newGenesisBlock);
121 | }
122 |
123 | /**
124 | * Test for {@link Block#isOnMainChain(LocalStore) ()}.
125 | */
126 | @Test
127 | public void testIsOnMainChain() {
128 | // Is true because TendermintMock returns always true
129 | assertTrue(this.block.isOnMainChain(this.localStore));
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/ChainTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 | import static org.junit.Assert.assertEquals;
6 | import static org.junit.Assert.assertTrue;
7 |
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
9 | import org.junit.Before;
10 | import org.junit.Test;
11 | import static org.mockito.Mockito.mock;
12 |
13 | /**
14 | * Test class for {@link Chain}.
15 | */
16 | public class ChainTest {
17 |
18 | private OwnNode ownNode;
19 |
20 | private Node node;
21 |
22 | private Chain chain;
23 |
24 | private LocalStore localStore;
25 |
26 | /**
27 | * Setup method.
28 | */
29 | @Before
30 | public void setUp() {
31 | this.ownNode = new OwnNode(0);
32 | this.localStore = new LocalStore(this.ownNode, null, null, false);
33 | this.node = mock(Node.class);
34 | this.chain = new Chain(this.node);
35 | }
36 |
37 | /**
38 | * Test for {@link Chainw#update()}.
39 | */
40 | @Test
41 | public void testUpdate_EmptyUpdate() {
42 | List updateList = new ArrayList<>();
43 | this.chain.update(updateList, localStore);
44 |
45 | assertTrue(this.chain.getBlocks().isEmpty());
46 | }
47 |
48 | /**
49 | * Test for {@link Chainw#update()}.
50 | */
51 | @Test
52 | public void testUpdate_EmptyChain() {
53 | List updateList = new ArrayList<>();
54 | updateList.add(new Block(0, this.node, new ArrayList<>()));
55 | this.chain.update(updateList, localStore);
56 |
57 | assertEquals(updateList, this.chain.getBlocks());
58 | }
59 |
60 | /**
61 | * Test for {@link Chainw#update()}.
62 | */
63 | @Test
64 | public void testUpdate_NotEmptyChain() {
65 | List updateList = new ArrayList<>();
66 | updateList.add(new Block(0, this.node, new ArrayList<>()));
67 | this.chain.update(updateList, localStore);
68 | updateList.add(new Block(1, this.node, new ArrayList<>()));
69 | updateList.add(new Block(2, this.node, new ArrayList<>()));
70 | this.chain.update(updateList, localStore);
71 |
72 | assertEquals(updateList, this.chain.getBlocks());
73 | }
74 |
75 | }
76 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/Ed25519KeyTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import java.security.InvalidKeyException;
4 | import java.security.NoSuchAlgorithmException;
5 | import java.security.SignatureException;
6 | import static org.junit.Assert.*;
7 |
8 | import org.junit.Test;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Utils;
10 | import org.junit.Before;
11 |
12 | /**
13 | * Test class for {@link Ed25519Key}.
14 | */
15 | public class Ed25519KeyTest {
16 |
17 | private Ed25519Key validKey;
18 |
19 | private Ed25519Key invalidKey;
20 |
21 | /**
22 | * Setup method.
23 | */
24 | @Before
25 | public void setUp() {
26 | byte[] validPub = Utils.hexStringToBytes("BE8933DFF1600C026E34718F1785A4CDEAB90C35698B394E38B6947AE91DE116");
27 | byte[] validPriv = Utils.hexStringToBytes("547AA07C7A8CE16C5CB2A40C6C26D15B0A32960410A9F1EA6E50B636F1AB389"
28 | + "ABE8933DFF1600C026E34718F1785A4CDEAB90C35698B394E38B6947AE91DE116");
29 | this.validKey = new Ed25519Key(validPriv, validPub);
30 |
31 | byte[] invalidPriv = Utils.hexStringToBytes("0000A07C7A8CE16C5CB2A40C6C26D15B0A32960410A9F1EA6E50B636F1AB389"
32 | + "ABE8933DFF1600C026E34718F1785A4CDEAB90C35698B394E38B6947AE91DE116");
33 | this.invalidKey = new Ed25519Key(invalidPriv, validPub);
34 | }
35 |
36 | /**
37 | * Test for {@link Ed25519Key#sign(byte[], byte[])}.
38 | */
39 | @Test
40 | public void testSign_Valid() {
41 | byte[] message = "testing message".getBytes();
42 |
43 | try {
44 | byte[] signature = Ed25519Key.sign(message, this.validKey.getPrivateKey());
45 | boolean valid = Ed25519Key.verify(message, signature, this.validKey.getPublicKey());
46 |
47 | assertTrue(valid);
48 | } catch (InvalidKeyException | NoSuchAlgorithmException | SignatureException ex) {
49 | fail();
50 | }
51 | }
52 |
53 | /**
54 | * Test for {@link Ed25519Key#sign(byte[], byte[])}.
55 | */
56 | @Test
57 | public void testSign_Invalid() {
58 | byte[] message = "testing message".getBytes();
59 |
60 | try {
61 | byte[] signature = Ed25519Key.sign(message, this.invalidKey.getPrivateKey());
62 | boolean valid = Ed25519Key.verify(message, signature, this.invalidKey.getPublicKey());
63 |
64 | assertFalse(valid);
65 | } catch (InvalidKeyException | NoSuchAlgorithmException | SignatureException ex) {
66 | fail();
67 | }
68 | }
69 |
70 | /**
71 | * Test for {@link Ed25519Key#generateKeys()}.
72 | */
73 | @Test
74 | public void testGenerateKeys_Valid() {
75 | Ed25519Key keyPair = new Ed25519Key();
76 | byte[] pub = keyPair.getPublicKey();
77 | byte[] priv = keyPair.getPrivateKey();
78 | byte[] message = "testing message".getBytes();
79 |
80 | try {
81 | byte[] signature = Ed25519Key.sign(message, priv);
82 | boolean valid = Ed25519Key.verify(message, signature, pub);
83 |
84 | assertTrue(valid);
85 | } catch (InvalidKeyException | NoSuchAlgorithmException | SignatureException ex) {
86 | fail();
87 | }
88 | }
89 |
90 | /**
91 | * Test for {@link Ed25519Key#sign()} and {@link Ed25519Key#verify()}.
92 | */
93 | @Test
94 | public void testSignVerify_Valid() {
95 | Ed25519Key keyPair = new Ed25519Key();
96 | byte[] message = "testing message".getBytes();
97 |
98 | try {
99 | byte[] signature = keyPair.sign(message);
100 | boolean valid = keyPair.verify(message, signature);
101 |
102 | assertTrue(valid);
103 | } catch (InvalidKeyException | NoSuchAlgorithmException | SignatureException ex) {
104 | fail();
105 | }
106 | }
107 |
108 | /**
109 | * Test for {@link Ed25519Key#verify(byte[], byte[], byte[]) ()}.
110 | */
111 | @Test
112 | public void testVerify_Invalid() {
113 | byte[] message = "testing message".getBytes();
114 | byte[] signature = new byte[10];
115 |
116 | try {
117 | Ed25519Key.verify(message, signature, this.validKey.getPublicKey());
118 |
119 | fail();
120 | } catch (SignatureException ex) {
121 | // Good
122 | }
123 | }
124 |
125 | /**
126 | * Test for {@link Ed25519Key#equals()}.
127 | */
128 | @Test
129 | public void testEquals_Valid() {
130 | Ed25519Key keyPair = new Ed25519Key();
131 | Ed25519Key newKeyPair = new Ed25519Key(keyPair.getPrivateKey(), keyPair.getPublicKey());
132 |
133 | assertEquals(keyPair, newKeyPair);
134 | }
135 |
136 | /**
137 | * Test for {@link Ed25519Key#hashCode() ()}.
138 | */
139 | @Test
140 | public void testHashCode() {
141 | assertNotEquals(this.validKey.hashCode(), this.invalidKey.hashCode());
142 | }
143 |
144 | }
145 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/NodeTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import java.util.ArrayList;
4 | import org.junit.Test;
5 | import static org.junit.Assert.*;
6 |
7 | /**
8 | * Class to test {@link Node}.
9 | */
10 | public class NodeTest {
11 |
12 | /**
13 | * Test for {@link Node#updateMetaKnowledge(Proof) }.
14 | */
15 | @Test
16 | public void testUpdateMetaKnowledge() {
17 | Ed25519Key key = new Ed25519Key();
18 | Node node = new Node(1, key.getPublicKey(), "127.0.0.1", 1234);
19 | Node otherNode = new Node(2);
20 | Proof proof = new Proof(null);
21 | proof.addBlock(new Block(1, otherNode, new ArrayList<>()));
22 | proof.addBlock(new Block(2, otherNode, new ArrayList<>()));
23 | proof.addBlock(new Block(3, otherNode, new ArrayList<>()));
24 | node.updateMetaKnowledge(proof);
25 |
26 | assertEquals(3, node.getMetaKnowledge().get(otherNode.getId()).intValue());
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/Sha256HashTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model;
2 |
3 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Utils;
4 | import static org.junit.Assert.assertEquals;
5 | import static org.junit.Assert.assertNotEquals;
6 | import org.junit.Test;
7 |
8 | /**
9 | * Class to test {@link Sha256Hash}.
10 | */
11 | public class Sha256HashTest {
12 |
13 | /**
14 | * Test for {@link Sha256Hash#Sha256Hash(java.lang.String) }.
15 | */
16 | @Test
17 | public void testConstuctorMessage() {
18 | Sha256Hash hash = new Sha256Hash("hello");
19 | String expectedStr = "2CF24DBA5FB0A30E26E83B2AC5B9E29E1B161E5C1FA7425E73043362938B9824";
20 |
21 | assertEquals(expectedStr, hash.toString().toUpperCase());
22 | }
23 |
24 | /**
25 | * Test for {@link Sha256Hash#Sha256Hash(byte[]) }.
26 | */
27 | @Test
28 | public void testConstructorBytes() {
29 | Sha256Hash hash = new Sha256Hash(Utils.hexStringToBytes("ABBA"));
30 |
31 | assertNotEquals("ABBA", hash.toString());
32 | }
33 |
34 | /**
35 | * Test for {@link Sha256Hash#withHash(byte[])}.
36 | */
37 | @Test
38 | public void testWith() {
39 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("ABBA"));
40 |
41 | assertNotEquals("ABBA", hash.toString());
42 | }
43 |
44 | /**
45 | * Test for {@link Sha256Hash#equals(java.lang.Object)}.
46 | */
47 | @Test
48 | public void testEquals() {
49 | Sha256Hash hash = new Sha256Hash("hello");
50 | Sha256Hash otherHash = new Sha256Hash("hello");
51 |
52 | assertEquals(hash, otherHash);
53 | }
54 |
55 | /**
56 | * Test for {@link Sha256Hash#equals(java.lang.Object)}.
57 | */
58 | @Test
59 | public void testHashCode() {
60 | Sha256Hash hash = new Sha256Hash("hello");
61 | Sha256Hash otherHash = new Sha256Hash("hello2");
62 |
63 | assertNotEquals(hash.hashCode(), otherHash.hashCode());
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/mainchain/tendermint/ABCIClientTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model.mainchain.tendermint;
2 |
3 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.BlockAbstract;
4 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Sha256Hash;
5 | import nl.tudelft.blockchain.scaleoutdistributedledger.test.utils.SilencedTestClass;
6 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Utils;
7 |
8 | import org.json.JSONArray;
9 | import org.json.JSONObject;
10 | import org.junit.Before;
11 | import org.junit.Test;
12 |
13 | import java.util.List;
14 |
15 | import static org.junit.Assert.*;
16 | import static org.mockito.Mockito.*;
17 |
18 | /**
19 | * Test class for {@link ABCIClient}.
20 | * Tests cases that log warnings, so logging is silenced.
21 | */
22 | public class ABCIClientTest extends SilencedTestClass {
23 | private ABCIClient instance;
24 |
25 | /**
26 | * Create a fresh client for each test.
27 | */
28 | @Before
29 | public void setUp() {
30 | this.instance = spy(new ABCIClient("localhost:9998"));
31 | }
32 |
33 | /**
34 | * Test a successful commit.
35 | */
36 | @Test
37 | public void testCommitSuccess() {
38 | String hash = "AAFF";
39 | BlockAbstract abs = new BlockAbstract(0, 0, null, null);
40 | JSONObject json = new JSONObject();
41 | json.put("result", json);
42 | json.put("deliver_tx", json);
43 | json.put("code", 0);
44 | json.put("hash", hash);
45 |
46 | doReturn(json).when(instance).sendRequest(anyString(), any());
47 | assertArrayEquals(Utils.hexStringToBytes(hash), instance.commit(abs));
48 | }
49 |
50 | /**
51 | * Test a commit that returns an error.
52 | */
53 | @Test
54 | public void testCommitError() {
55 | BlockAbstract abs = new BlockAbstract(0, 0, null, null);
56 | JSONObject json = new JSONObject();
57 | JSONObject jsonError = new JSONObject();
58 | json.put("error", jsonError);
59 | jsonError.put("data", "An error message");
60 |
61 | doReturn(json).when(instance).sendRequest(anyString(), any());
62 | assertNull(instance.commit(abs));
63 | }
64 |
65 | /**
66 | * Test a commit where the connection fails.
67 | */
68 | @Test
69 | public void testCommitFail() {
70 | BlockAbstract abs = new BlockAbstract(0, 0, null, null);
71 |
72 | doReturn(null).when(instance).sendRequest(anyString(), any());
73 | assertNull(instance.commit(abs));
74 | }
75 |
76 | /**
77 | * Test a successful query.
78 | */
79 | @Test
80 | public void testQuerySuccess() {
81 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF00"));
82 | JSONObject json = new JSONObject();
83 | json.put("result", 42);
84 |
85 | doReturn(json).when(instance).sendRequest(anyString(), any());
86 | assertTrue(instance.query(hash));
87 | }
88 |
89 | /**
90 | * Test a query that returns an error.
91 | */
92 | @Test
93 | public void testQueryError() {
94 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF00"));
95 | JSONObject json = new JSONObject();
96 | json.put("error", 42);
97 |
98 | doReturn(json).when(instance).sendRequest(anyString(), any());
99 | assertFalse(instance.query(hash));
100 | }
101 |
102 | /**
103 | * Test a query on a failing connection.
104 | */
105 | @Test
106 | public void testQueryFail() {
107 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF00"));
108 |
109 | doReturn(null).when(instance).sendRequest(anyString(), any());
110 | assertFalse(instance.query(hash));
111 | }
112 |
113 | /**
114 | * Test a successful height lookup.
115 | */
116 | @Test
117 | public void testQueryHeightSuccess() {
118 | BlockAbstract abs1 = new BlockAbstract(0, 0, Sha256Hash.withHash(Utils.hexStringToBytes("11FF")), null);
119 | BlockAbstract abs2 = new BlockAbstract(0, 0, Sha256Hash.withHash(Utils.hexStringToBytes("AABB")), null);
120 |
121 | JSONObject json = new JSONObject();
122 | JSONArray jsonArray = new JSONArray();
123 | json.put("result", json);
124 | json.put("block", json);
125 | json.put("data", json);
126 | json.put("txs", jsonArray);
127 |
128 | jsonArray.put(Utils.bytesToBas64String(abs1.toBytes()));
129 | jsonArray.put(Utils.bytesToBas64String(abs2.toBytes()));
130 |
131 | doReturn(json).when(instance).sendRequest(anyString(), any());
132 |
133 | List result = instance.query(10);
134 | assertEquals(2, result.size());
135 | assertEquals(abs1.getBlockHash(), result.get(0).getBlockHash());
136 | }
137 |
138 | /**
139 | * Test a height lookup that gives a malformed result.
140 | */
141 | @Test
142 | public void testQueryHeightMalformed() {
143 | JSONObject json = new JSONObject();
144 | json.put("malformed", 42);
145 |
146 | doReturn(json).when(instance).sendRequest(anyString(), any());
147 |
148 | assertNull(instance.query(10));
149 | }
150 |
151 | /**
152 | * Test a height lookup that results in an error.
153 | */
154 | @Test
155 | public void testQueryHeightError() {
156 | JSONObject json = new JSONObject();
157 | JSONObject jsonError = new JSONObject();
158 | json.put("error", jsonError);
159 | jsonError.put("data", "An error message");
160 |
161 | doReturn(json).when(instance).sendRequest(anyString(), any());
162 |
163 | assertNull(instance.query(10));
164 | }
165 |
166 | /**
167 | * Test a height lookup when the connection fails.
168 | */
169 | @Test
170 | public void testQueryHeightFail() {
171 | doReturn(null).when(instance).sendRequest(anyString(), any());
172 | assertNull(instance.query(10));
173 | }
174 |
175 | /**
176 | * Test a successful status call.
177 | */
178 | @Test
179 | public void testStatusSuccess() {
180 | JSONObject json = new JSONObject();
181 | JSONObject jsonResult = new JSONObject();
182 | json.put("result", jsonResult);
183 |
184 | doReturn(json).when(instance).sendRequest(anyString(), any());
185 |
186 | assertEquals(jsonResult, instance.status());
187 | }
188 |
189 | /**
190 | * Test a status call that results in a fail.
191 | */
192 | @Test
193 | public void testStatusFail() {
194 | doReturn(null).when(instance).sendRequest(anyString(), any());
195 |
196 | assertEquals(0, instance.status().length());
197 | }
198 |
199 | }
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/model/mainchain/tendermint/TendermintChainTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.model.mainchain.tendermint;
2 |
3 | import com.github.jtendermint.jabci.socket.TSocket;
4 | import nl.tudelft.blockchain.scaleoutdistributedledger.Application;
5 | import nl.tudelft.blockchain.scaleoutdistributedledger.LocalStore;
6 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.BlockAbstract;
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Sha256Hash;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.mainchain.MainChain;
10 | import nl.tudelft.blockchain.scaleoutdistributedledger.test.utils.SilencedTestClass;
11 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Utils;
12 | import org.json.JSONObject;
13 | import org.junit.Before;
14 | import org.junit.Test;
15 | import org.mockito.invocation.InvocationOnMock;
16 | import org.mockito.stubbing.Answer;
17 |
18 | import java.util.ArrayList;
19 | import java.util.HashSet;
20 | import java.util.List;
21 | import java.util.Set;
22 |
23 | import static org.junit.Assert.*;
24 | import static org.mockito.Mockito.*;
25 |
26 | /**
27 | * Class testing the Tendermint implementation of the {@link MainChain} interface.
28 | * Tests cases that log warnings, so logging is silenced.
29 | */
30 | public class TendermintChainTest extends SilencedTestClass {
31 | private TendermintChain instance;
32 | private ABCIClient clientMock;
33 | private TSocket socketMock;
34 | private Set cache;
35 |
36 | /**
37 | * Create a fresh instance for each test.
38 | */
39 | @Before
40 | public void setUp() {
41 | clientMock = mock(ABCIClient.class);
42 | socketMock = mock(TSocket.class);
43 | cache = new HashSet<>();
44 | Application appMock = mock(Application.class);
45 | LocalStore localStoreMock = mock(LocalStore.class);
46 |
47 | when(appMock.getLocalStore()).thenReturn(localStoreMock);
48 | when(localStoreMock.getOwnNode()).thenReturn(new OwnNode(0));
49 |
50 | instance = new TendermintChain(clientMock, socketMock, cache, appMock);
51 | }
52 |
53 | /**
54 | * Test updating the cache.
55 | * Adds two blocks containing 3 abstracts and fails to trigger the loop.
56 | */
57 | @Test
58 | public void testInitialUpdateCache() {
59 | when(clientMock.query(anyLong())).thenAnswer(new Answer>() {
60 | private int c;
61 |
62 | @Override
63 | public List answer(InvocationOnMock invocation) {
64 | List data = new ArrayList<>();
65 | if (c == 0) {
66 | data.add(new BlockAbstract(0, 0, new Sha256Hash(Utils.hexStringToBytes("FF44")), null));
67 | data.add(new BlockAbstract(0, 0, new Sha256Hash(Utils.hexStringToBytes("FF55")), null));
68 | } else {
69 | data.add(new BlockAbstract(0, 0, new Sha256Hash(Utils.hexStringToBytes("FF66")), null));
70 | }
71 | c++;
72 | return data;
73 | }
74 | });
75 |
76 | when(clientMock.status()).thenAnswer(new Answer() {
77 | private JSONObject json;
78 |
79 | @Override
80 | public JSONObject answer(InvocationOnMock invocation) {
81 |
82 | if (json == null) {
83 | json = new JSONObject();
84 | } else {
85 | json.put("latest_block_height", 2L);
86 | }
87 | return json;
88 | }
89 | });
90 |
91 | instance.initialUpdateCache();
92 |
93 | assertEquals(3, cache.size());
94 | assertEquals(2, instance.getCurrentHeight());
95 | }
96 |
97 | /**
98 | * Test if stopping stops the socket.
99 | */
100 | @Test
101 | public void testStop() {
102 | instance.stop();
103 | verify(socketMock, times(1)).stop();
104 | }
105 |
106 | /**
107 | * Test if committing calls the client and if the hashes are set correctly.
108 | */
109 | @Test
110 | public void testCommitAbstract() {
111 | BlockAbstract abs = new BlockAbstract(0, 0, Sha256Hash.withHash(Utils.hexStringToBytes("11FF")), null);
112 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF11"));
113 |
114 | when(clientMock.commit(any(BlockAbstract.class))).thenReturn(Utils.hexStringToBytes("FF11"));
115 |
116 | Sha256Hash result = instance.commitAbstract(abs);
117 | assertEquals(hash, result);
118 | assertEquals(hash, abs.getAbstractHash());
119 | verify(clientMock, times(1)).commit(any(BlockAbstract.class));
120 | }
121 |
122 | /**
123 | * Test the case where comitting fails.
124 | */
125 | @Test
126 | public void testCommitAbstractFail() {
127 | BlockAbstract abs = new BlockAbstract(0, 0, Sha256Hash.withHash(Utils.hexStringToBytes("11FF")), null);
128 | when(clientMock.commit(any(BlockAbstract.class))).thenReturn(null);
129 |
130 | assertNull(instance.commitAbstract(abs));
131 | }
132 |
133 | /**
134 | * Test isPresent when the data is in the cache.
135 | */
136 | @Test
137 | public void testIsPresentAlreadyInCache() {
138 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF11"));
139 | cache.add(hash);
140 |
141 | assertTrue(instance.isPresent(hash));
142 | }
143 |
144 | /**
145 | * Test isPresent when the data is not in the cache initially and an update does not fix that.
146 | */
147 | @Test
148 | public void testIsPresentNotInCacheAfterUpdate() {
149 | Sha256Hash hash1 = Sha256Hash.withHash(Utils.hexStringToBytes("FF11"));
150 | Sha256Hash hash2 = Sha256Hash.withHash(Utils.hexStringToBytes("AAFF"));
151 |
152 | JSONObject json = new JSONObject();
153 | json.put("latest_block_height", 1);
154 | when(clientMock.status()).thenReturn(json);
155 | List abss = new ArrayList<>();
156 | abss.add(new BlockAbstract(0, 0, hash2, null));
157 | when(clientMock.query(anyLong())).thenReturn(abss);
158 |
159 | assertFalse(instance.isPresent(hash1));
160 | }
161 |
162 | /**
163 | * Test adding to the cache.
164 | */
165 | @Test
166 | public void testAddToCache() {
167 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF22"));
168 | assertTrue(instance.addToCache(hash));
169 | assertTrue(cache.contains(hash));
170 | }
171 |
172 | /**
173 | * Test adding an existing item to the cache.
174 | */
175 | @Test
176 | public void testAddToCacheFails() {
177 | Sha256Hash hash = Sha256Hash.withHash(Utils.hexStringToBytes("FF22"));
178 | cache.add(hash);
179 |
180 | assertFalse(instance.addToCache(hash));
181 | }
182 |
183 | }
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/test/utils/SilencedTestClass.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.test.utils;
2 |
3 | import nl.tudelft.blockchain.scaleoutdistributedledger.utils.Log;
4 | import org.junit.AfterClass;
5 | import org.junit.BeforeClass;
6 |
7 | import java.util.logging.Level;
8 |
9 | public class SilencedTestClass {
10 | private static Level level;
11 |
12 | /**
13 | * Store the current log level (for restoring) and disable logging.
14 | */
15 | @BeforeClass
16 | public static void setUpClass() {
17 | level = Log.getLogLevel();
18 | Log.setLogLevel(Level.OFF);
19 | }
20 |
21 | /**
22 | * Re-enable the logging with the old level.
23 | */
24 | @AfterClass
25 | public static void tearDownClass() throws Exception {
26 | Log.setLogLevel(level);
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/test/utils/TestHelper.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.test.utils;
2 |
3 | import java.util.Map;
4 | import java.util.stream.Collectors;
5 | import java.util.stream.IntStream;
6 |
7 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Block;
8 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Node;
9 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.OwnNode;
10 | import nl.tudelft.blockchain.scaleoutdistributedledger.model.Transaction;
11 | import nl.tudelft.blockchain.scaleoutdistributedledger.simulation.tendermint.TendermintHelper;
12 |
13 | /**
14 | * Helper class for tests.
15 | */
16 | public final class TestHelper {
17 | private TestHelper() {}
18 |
19 | /**
20 | * @param ownNode - the own node
21 | * @param nrOfNodes - the number of nodes
22 | * @param amount - the amount each node gets
23 | * @return - the genesis block
24 | */
25 | public static Block generateGenesis(OwnNode ownNode, int nrOfNodes, long amount) {
26 | Map nodeList = IntStream.rangeClosed(0, nrOfNodes)
27 | .boxed()
28 | .collect(Collectors.toMap(i -> i, Node::new));
29 | nodeList.put(ownNode.getId(), ownNode);
30 | Block genesisBlock = TendermintHelper.generateGenesisBlock(amount, nodeList);
31 |
32 | for (Node node : nodeList.values()) {
33 | node.getChain().setGenesisBlock(genesisBlock);
34 | }
35 | return genesisBlock;
36 | }
37 |
38 | /**
39 | * @param genesisBlock - the genesis block
40 | * @return - the map of nodes
41 | */
42 | public static Map getNodeList(Block genesisBlock) {
43 | return genesisBlock.getTransactions()
44 | .stream()
45 | .map(Transaction::getReceiver)
46 | .collect(Collectors.toMap(Node::getId, n -> n));
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/test/java/nl/tudelft/blockchain/scaleoutdistributedledger/utils/UtilsTest.java:
--------------------------------------------------------------------------------
1 | package nl.tudelft.blockchain.scaleoutdistributedledger.utils;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.*;
6 |
7 | /**
8 | * Test class for {@link Utils}.
9 | */
10 | public class UtilsTest {
11 | /**
12 | * Test the byte array conversion without using the 0x prefix.
13 | */
14 | @Test
15 | public void testHexStringToByteArray_WithoutPrefix_Uppercase() {
16 | String test = "091AFE";
17 | assertArrayEquals(new byte[] {0x09, 0x1A, (byte) 0xFE}, Utils.hexStringToBytes(test));
18 | }
19 |
20 | /**
21 | * Test the byte array conversion without using the 0x prefix.
22 | */
23 | @Test
24 | public void testHexStringToByteArray_WithoutPrefix_Lowercase() {
25 | String test = "091afe";
26 | assertArrayEquals(new byte[] {0x09, 0x1A, (byte) 0xFE}, Utils.hexStringToBytes(test));
27 | }
28 |
29 | /**
30 | * Test the byte array conversion with an invalid input.
31 | */
32 | @Test(expected = IllegalArgumentException.class)
33 | public void testHexStringToByteArray_Invalid() {
34 | String test = "00G0FF";
35 | Utils.hexStringToBytes(test);
36 | }
37 |
38 | /**
39 | * Test the byte array conversion to a String.
40 | */
41 | @Test
42 | public void testByteArrayToHexString() {
43 | byte[] array = new byte[]{0x00, 0x12, (byte) 0xFF};
44 | assertEquals("0012ff", Utils.bytesToHexString(array));
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/test/resources/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blockchain-lab/ScaleOutDistributedLedger/1bb03b7eeb20b609033cc5a7797df654cb8ce061/src/test/resources/.gitignore
--------------------------------------------------------------------------------
/tracker-server/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 | "presets": ["es2015"]
3 | }
--------------------------------------------------------------------------------
/tracker-server/.eslintrc:
--------------------------------------------------------------------------------
1 | {
2 | "parser": "babel-eslint",
3 | "extends": "airbnb/base",
4 | "env": {
5 | "es6": true,
6 | "node": true,
7 | "mocha": true
8 | },
9 | "ecmaFeatures": {
10 | "classes": true,
11 | "modules": true
12 | },
13 | "rules": {
14 | "comma-dangle": 0,
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/tracker-server/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/*
2 | .idea/*
3 | dist/*
4 | data.csv
5 | nodelist.json
6 | transactionlist.json
--------------------------------------------------------------------------------
/tracker-server/app.js:
--------------------------------------------------------------------------------
1 | import bodyParser from 'body-parser';
2 | import cookieParser from 'cookie-parser';
3 | import Debug from 'debug';
4 | import logger from 'morgan';
5 | import express from 'express';
6 | import http from 'http';
7 | import index from './routes/index';
8 | import NodeList from './model/NodeList';
9 | import TransactionList from './model/TransactionList';
10 | import path from "path";
11 | const sseMW = require('./helpers/sse');
12 |
13 | const app = express();
14 | const debug = Debug('test:app');
15 |
16 | app.use(sseMW.sseMiddleware);
17 |
18 | app.use(logger('dev'));
19 | app.use(bodyParser.json());
20 | app.use(bodyParser.urlencoded({
21 | extended: false
22 | }));
23 | app.set('views', path.join(__dirname, '../views'));
24 | app.set('view engine', 'ejs');
25 | app.use(express.static(path.join(__dirname, '../public')));
26 |
27 | const port = normalizePort(process.env.PORT || '3000');
28 | app.set('port', port);
29 | const server = http.createServer(app);
30 |
31 | app.use(cookieParser());
32 |
33 | app.nodeList = new NodeList();
34 | app.transactionList = new TransactionList();
35 | app.use('/', index);
36 |
37 | server.listen(port);
38 | server.on('listening', onListening);
39 |
40 | // catch 404 and forward to error handler
41 | app.use((req, res, next) => {
42 | const err = new Error('Not Found');
43 | err.status = 404;
44 | next(err);
45 | });
46 |
47 | // error handler
48 | /* eslint no-unused-vars: 0 */
49 | app.use((err, req, res, next) => {
50 | console.log(err);
51 | // set locals, only providing error in development
52 | res.locals.message = err.message;
53 | res.locals.error = req.app.get('env') === 'development' ? err : {};
54 | // render the error page
55 | res.status(err.status || 500);
56 | res.json(err);
57 | });
58 |
59 | // Handle uncaughtException
60 | process.on('uncaughtException', (err) => {
61 | debug('Caught exception: %j', err);
62 | process.exit(1);
63 | });
64 |
65 | /**
66 | * Normalize a port into a number, string, or false.
67 | */
68 |
69 | function normalizePort(val) {
70 | let port = parseInt(val, 10);
71 |
72 | if (isNaN(port)) {
73 | // named pipe
74 | return val;
75 | }
76 |
77 | if (port >= 0) {
78 | // port number
79 | return port;
80 | }
81 |
82 | return false;
83 | }
84 |
85 | /**
86 | * Event listener for HTTP server "listening" event.
87 | */
88 | function onListening() {
89 | const addr = server.address();
90 | const bind = typeof addr === 'string'
91 | ? 'pipe ' + addr
92 | : 'port ' + addr.port;
93 | console.log('Listening on ' + bind);
94 | }
95 |
96 | export default app;
97 |
--------------------------------------------------------------------------------
/tracker-server/helpers/sse.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | console.log("loading sse.js");
4 |
5 | // ... with this middleware:
6 | function sseMiddleware(req, res, next) {
7 | res.sseConnection = new Connection(res);
8 | next();
9 | }
10 | exports.sseMiddleware = sseMiddleware;
11 | /**
12 | * A Connection is a simple SSE manager for 1 client.
13 | */
14 | var Connection = (function () {
15 | function Connection(res) {
16 | this.res = res;
17 | }
18 | Connection.prototype.setup = function () {
19 | this.res.writeHead(200, {
20 | 'Content-Type': 'text/event-stream',
21 | 'Cache-Control': 'no-cache',
22 | 'Connection': 'keep-alive'
23 | });
24 | };
25 | Connection.prototype.send = function (data) {
26 | this.res.write("data: " + JSON.stringify(data) + "\n\n");
27 | };
28 | return Connection;
29 | }());
30 |
31 | exports.Connection = Connection;
32 | /**
33 | * A Topic handles a bundle of connections with cleanup after lost connection.
34 | */
35 | var Topic = (function () {
36 | function Topic() {
37 | this.connections = [];
38 | }
39 | Topic.prototype.add = function (conn) {
40 | const connections = this.connections;
41 | connections.push(conn);
42 | console.log('New client connected, now: ', connections.length);
43 | conn.res.on('close', function () {
44 | const i = connections.indexOf(conn);
45 | if (i >= 0) {
46 | connections.splice(i, 1);
47 | }
48 | console.log('Client disconnected, now: ', connections.length);
49 | });
50 | };
51 | Topic.prototype.forEach = function (cb) {
52 | this.connections.forEach(cb);
53 | };
54 | return Topic;
55 | }());
56 | exports.Topic = Topic;
--------------------------------------------------------------------------------
/tracker-server/model/Node.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Class to store Node information.
3 | */
4 | class Node {
5 |
6 | /**
7 | * Constructor.
8 | * @param id - the id of this node.
9 | * @param address - the address of this node.
10 | * @param port - the port of this node.
11 | */
12 | constructor(id, address, port, publicKey) {
13 | this.id = id;
14 | this.address = address;
15 | this.port = port;
16 | this.publicKey = publicKey;
17 | this.lastSeen = new Date();
18 | this.running = false;
19 | }
20 | }
21 |
22 | module.exports = Node;
23 |
--------------------------------------------------------------------------------
/tracker-server/model/NodeList.js:
--------------------------------------------------------------------------------
1 | import Node from './Node';
2 |
3 | /**
4 | * Class to store a list of nodes.
5 | */
6 | class NodeList {
7 |
8 | /**
9 | * Constructor.
10 | */
11 | constructor() {
12 | this.nodes = [];
13 | }
14 |
15 | /**
16 | *
17 | * Adds or updates a node to/in the nodelist.
18 | * @param id - id of the node to update
19 | * @param address - new address
20 | * @param port - new port
21 | * @param publicKey - new public key
22 | * @returns {boolean} - whether the id was valid.
23 | */
24 | updateNode(id, address, port, publicKey) {
25 | if(id < this.nodes.length) {
26 | if (!!this.nodes[id]) return false;
27 | this.nodes[id].address = address;
28 | this.nodes[id].port = port;
29 | this.nodes[id].publicKey = publicKey;
30 | return true;
31 | }
32 | return false;
33 | }
34 |
35 | /**
36 | * Register a new node.
37 | * @param id - the id of the new node
38 | * @param address - the address of the new node
39 | * @param port - the port of the new node
40 | * @param publicKey - the public key of the new node
41 | * @returns {number} - the id of the new node
42 | */
43 | registerNode(id, address, port, publicKey) {
44 | this.nodes[id] = new Node(id, address, port, publicKey)
45 | return id;
46 | }
47 |
48 | /**
49 | * Set the status of the node.
50 | * @param id - the id of the node that is marked
51 | * @param running - the new status of the node
52 | * @returns {boolean} - whether the id was valid.
53 | */
54 | setNodeStatus(id, running) {
55 | if(id < this.nodes.length) {
56 | this.nodes[id].running = running;
57 | return true;
58 | }
59 | return false;
60 | }
61 |
62 | /**
63 | * Get the number of nodes that are running.
64 | * @returns {int} - the number of nodes that is initialized
65 | */
66 | getRunning() {
67 | let count = 0;
68 | for (let i = 0; i < this.nodes.length; ++i) {
69 | if (!!this.nodes[i] && this.nodes[i].running) {
70 | count ++;
71 | }
72 | }
73 | return count
74 | }
75 |
76 | /**
77 | * Gets the node at the specified id, if present.
78 | * @param id - the id of the node to get.
79 | * @returns {Node} - the node at the specified id.
80 | */
81 | getNode(id) {
82 | if(id < this.nodes.length) {
83 | return this.nodes[id];
84 | }
85 | return null;
86 | }
87 |
88 | /**
89 | * Get the full list of nodes.
90 | * @returns {Array} - the list of nodes.
91 | */
92 | getNodes() {
93 | return this.nodes;
94 | }
95 |
96 | /** Get the number of registered nodes.
97 | * @returns {number} - the number of registered nodes on the server
98 | */
99 | getSize() {
100 | if (this.nodes) {
101 | let count = 0;
102 | for (let i = 0; i < this.nodes.length; ++i) {
103 | if (this.nodes[i]) {
104 | count ++;
105 | }
106 | }
107 | return count;
108 | } else {
109 | return 0;
110 | }
111 | }
112 |
113 | getGraphNodes() {
114 | const nodes = [];
115 | this.nodes.forEach(node => {
116 | nodes.push({id: node.id, label: node.id.toString()});
117 | });
118 | return nodes;
119 | }
120 | }
121 |
122 | module.exports = NodeList;
123 |
--------------------------------------------------------------------------------
/tracker-server/model/Transaction.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Class to store transaction information.
3 | */
4 | class Transaction {
5 |
6 | /**
7 | * Constructor.
8 | * @param from - id of sender node
9 | * @param to - id of receiver node
10 | * @param amount - amount of transaction
11 | * @param remainder - remainder of transaction
12 | * @param numberOfChains - number of chains sent in proof
13 | * @param numberOfBlocks - number of blocks sent in proof
14 | */
15 | constructor(from, to, amount, remainder, numberOfChains, numberOfBlocks) {
16 | this.from = from;
17 | this.to = to;
18 | this.amount = amount;
19 | this.remainder = remainder;
20 | this.numberOfChains = numberOfChains;
21 | this.numberOfBlocks = numberOfBlocks;
22 | }
23 | }
24 |
25 | module.exports = Transaction;
--------------------------------------------------------------------------------
/tracker-server/model/TransactionList.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Class to store a list of all transactions.
3 | */
4 | class TransactionList {
5 |
6 | /**
7 | * Constructor.
8 | */
9 | constructor() {
10 | // Store transactions in a dictionary
11 | this.transactions = {};
12 | this.numberOfTransactions = 0;
13 | this.numberOfChains = 0;
14 | this.numberOfBlocks = 0;
15 | this.numbersArray = [];
16 | }
17 |
18 | /**
19 | * Add a transaction to the transaction list.
20 | * @param transaction - the transaction to add
21 | */
22 | addTransaction(transaction) {
23 | this.numberOfTransactions += 1;
24 | this.numberOfChains += transaction.numberOfChains;
25 | this.numberOfBlocks += transaction.numberOfBlocks;
26 |
27 | // Make sure we use a consistent key for all transactions between the same two nodes
28 | let key = [transaction.from, transaction.to];
29 | if(transaction.from > transaction.to)
30 | key = [transaction.to, transaction.from];
31 |
32 | if(!this.transactions[key])
33 | this.transactions[key] = [transaction];
34 | else
35 | this.transactions[key].push(transaction);
36 | }
37 |
38 | /**
39 | * Gets the edge weight between two nodes.
40 | * @param node1 - the first node
41 | * @param node2 - the second node
42 | * @returns {number}
43 | */
44 | getEdgeWeight(node1, node2) {
45 | let key = [node1, node2];
46 | if(node1 > node2) {
47 | key = [node2, node1];
48 | }
49 | return this.getEdgeWeightWithKey(key);
50 | }
51 |
52 | /**
53 | * Gets the edge weight for a certain key.
54 | * @param key - the key
55 | * @returns {number}
56 | */
57 | getEdgeWeightWithKey(key) {
58 | if(!this.transactions[key]) return 0;
59 |
60 | // TODO: something other than number of transactions?
61 | return this.transactions[key].length;
62 | }
63 |
64 | /**
65 | * Returns parsed edges for the graph.
66 | * @returns {Array}
67 | */
68 | getGraphEdges() {
69 | const edges = [];
70 | for (const key of Object.keys(this.transactions)) {
71 | const keyArray = key.split(",");
72 | const weight = this.getEdgeWeightWithKey(key);
73 | edges.push({from: keyArray[0], to: keyArray[1], value: weight});
74 | }
75 | return edges;
76 | }
77 |
78 | /**
79 | * Returns a JSON object containing some interesting number.
80 | * @returns {{numberOfTransactions: number, averageNumberOfBlocks: number, averageNumberOfChains: number}}
81 | */
82 | getNumbers() {
83 | let averageNumberOfChains = 0,
84 | averageNumberOfBlocks = 0;
85 | if(this.numberOfTransactions !== 0) {
86 | averageNumberOfBlocks = this.numberOfBlocks / this.numberOfTransactions;
87 | averageNumberOfChains = this.numberOfChains / this.numberOfTransactions;
88 | }
89 | return {
90 | numberOfTransactions: this.numberOfTransactions,
91 | averageNumberOfBlocks: averageNumberOfBlocks,
92 | averageNumberOfChains: averageNumberOfChains
93 | };
94 | }
95 |
96 | /**
97 | * Adds numbers data point to the array.
98 | */
99 | addNumbersToArray() {
100 | const numbers = this.getNumbers();
101 | if(numbers.numberOfTransactions !== 0 || numbers.averageNumberOfBlocks !== 0 || numbers.averageNumberOfChains !== 0) {
102 | this.numbersArray.push(numbers);
103 | }
104 | }
105 |
106 | /**
107 | * Gets the numbers array.
108 | * @returns {Array}
109 | */
110 | getNumbersArray() {
111 | return this.numbersArray;
112 | }
113 | }
114 |
115 | module.exports = TransactionList;
--------------------------------------------------------------------------------
/tracker-server/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "tracker-server",
3 | "version": "1.0.0",
4 | "description": "Tracker server for scale-out blockchain project",
5 | "main": "app.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1",
8 | "build": "rimraf dist/ && babel ./ --out-dir dist/ --ignore ./node_modules,./.babelrc,./package.json,./npm-debug.log,./public,./views--copy-files",
9 | "start": "npm run build && node dist/app.js"
10 | },
11 | "author": "Bart de Jonge",
12 | "license": "ISC",
13 | "devDependencies": {
14 | "babel-cli": "^6.26.0",
15 | "babel-core": "^6.26.0",
16 | "babel-preset-es2015": "^6.24.1",
17 | "rimraf": "^2.6.2"
18 | },
19 | "dependencies": {
20 | "body-parser": "latest",
21 | "cookie-parser": "^1.4.3",
22 | "csv-writer": "0.0.3",
23 | "debug": "latest",
24 | "ejs": "^2.5.7",
25 | "express": "^4.16.2",
26 | "fs": "0.0.1-security",
27 | "jsnetworkx": "^0.3.4",
28 | "morgan": "^1.9.0"
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/tracker-server/public/images/background.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blockchain-lab/ScaleOutDistributedLedger/1bb03b7eeb20b609033cc5a7797df654cb8ce061/tracker-server/public/images/background.png
--------------------------------------------------------------------------------
/tracker-server/public/images/background.psd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blockchain-lab/ScaleOutDistributedLedger/1bb03b7eeb20b609033cc5a7797df654cb8ce061/tracker-server/public/images/background.psd
--------------------------------------------------------------------------------
/tracker-server/public/javascripts/demo.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 | var source = new EventSource("../topn/updates");
3 | source.onmessage = function(event) {
4 | var data = JSON.parse(event.data);
5 | // $(".odometer").text(counter);
6 | network.setData({nodes: data.nodes, edges: data.edges});
7 | network.redraw();
8 | $(".transactions").text(data.numbers.numberOfTransactions);
9 | $(".chains").text(Math.round(data.numbers.averageNumberOfChains * 100) / 100);
10 | $(".blocks").text(Math.round(data.numbers.averageNumberOfBlocks * 100) / 100);
11 | };
12 |
13 | window.odometerOptions = {
14 | auto: false,
15 | format: '(,ddd).ddd', // Change how digit groups are formatted, and how many digits are shown after the decimal point
16 | duration: 100,
17 | animation: 'count'
18 | };
19 |
20 | var nodes = [];
21 | var edges = [];
22 | var network = null;
23 |
24 | function draw() {
25 |
26 | // Instantiate our network object.
27 | var container = document.getElementById('demo-graph');
28 | var data = {
29 | nodes: nodes,
30 | edges: edges
31 | };
32 | var options = {
33 | nodes: {
34 | shape: 'dot'
35 | },
36 | edges: {
37 | color: {
38 | opacity: 0.5
39 | },
40 | smooth: {
41 | type: 'discrete'
42 | }
43 | },
44 | layout: {
45 | randomSeed: 2
46 | },
47 | physics: {
48 | barnesHut: {
49 | springLength: 1000
50 | }
51 | },
52 | configure: {
53 | filter:function (option, path) {
54 | if (path.indexOf('physics') !== -1) {
55 | return true;
56 | }
57 | if (path.indexOf('smooth') !== -1 || option === 'smooth') {
58 | return true;
59 | }
60 | if (path.indexOf('color') !== -1 || option === 'color') {
61 | return true;
62 | }
63 | if (path.indexOf('nodes') !== -1) {
64 | return true;
65 | }
66 | return false;
67 | },
68 | container: document.getElementById('config')
69 | }
70 | };
71 | network = new vis.Network(container, data, options);
72 | }
73 | draw();
74 |
75 | var counter = 12;
76 |
77 | $("#saveButton").on("click", function() {
78 | $.ajax({
79 | method: 'POST',
80 | url: '/write-data'
81 | });
82 | });
83 | });
84 |
--------------------------------------------------------------------------------
/tracker-server/public/stylesheets/demo.css:
--------------------------------------------------------------------------------
1 | #demo-graph {
2 | width: 1000px;
3 | height: 600px;
4 | display: block;
5 | border: 2px solid black;
6 | margin: 30px auto auto;
7 | }
8 |
9 | .odometer {
10 | font-size: 50px;
11 | margin: auto;
12 | }
13 |
14 | .odometer_wrapper {
15 | text-align: center;
16 | }
17 |
18 | body {
19 | text-align: center;
20 | }
21 |
22 | .numbers_table {
23 | margin: auto;
24 | }
25 |
26 | .numbers_table tr.labels {
27 | font-size: 30px;
28 | font-weight: bold;
29 | }
30 |
31 | .numbers_table tr td {
32 | padding: 10px 20px;
33 | }
34 |
35 | h1 {
36 | font-size: 45px;
37 | }
38 |
39 | html {
40 | background: rgba(0, 0, 0, 0.1) url(/images/background.png) no-repeat fixed center center;
41 | -webkit-background-size: cover;
42 | -moz-background-size: cover;
43 | -o-background-size: cover;
44 | background-size: cover;
45 | }
46 |
--------------------------------------------------------------------------------
/tracker-server/routes/index.js:
--------------------------------------------------------------------------------
1 | import express from 'express';
2 | const router = express.Router();
3 | import app from '../app';
4 | import NodeList from '../model/NodeList';
5 | const sseMW = require('./../helpers/sse');
6 | const fs = require('fs');
7 | import Transaction from '../model/Transaction';
8 | import TransactionList from '../model/TransactionList';
9 |
10 | /**
11 | * Gets all nodes.
12 | */
13 | router.get('/', (req, res) => {
14 | res.json({
15 | nodes: app.nodeList.getNodes()
16 | });
17 | });
18 |
19 | /**
20 | * Updates a certain node. Body should contain id, address, port and publicKey.
21 | */
22 | router.post('/update-node', (req, res) => {
23 | if(!isPresent(req.body.id) || !isPresent(req.body.address) || !isPresent(req.body.port) || !isPresent(req.body.publicKey)) {
24 | res.status(403);
25 | res.json({success: false, err: 'Specify id, address, port and publicKey'});
26 | } else {
27 | if (app.nodeList.updateNode(req.body.id, req.body.address, req.body.port, req.body.publicKey)) {
28 | res.json({success: true});
29 | } else {
30 | res.status(403);
31 | res.json({success: false, err: 'invalid node'});
32 | }
33 | }
34 | });
35 |
36 | /**
37 | * Register a new node, body should contain id, address, port and publicKey.
38 | */
39 | router.post('/register-node', (req, res) => {
40 | if(!isPresent(req.body.address) || !isPresent(req.body.port) || !isPresent(req.body.publicKey) || !isPresent(req.body.id)) {
41 | res.status(403);
42 | res.json({success: false, err: 'Specify id, address, port and publicKey'});
43 | } else {
44 | const id = app.nodeList.registerNode(req.body.id, req.body.address, req.body.port, req.body.publicKey);
45 | updateSseClients();
46 | res.json({success: true, id: id});
47 | }
48 | });
49 |
50 | router.post('/register-transaction', (req, res) => {
51 | if(!isPresent(req.body.from) || !isPresent(req.body.to) || !isPresent(req.body.amount)|| !isPresent(req.body.remainder)|| !isPresent(req.body.numberOfChains) || !isPresent(req.body.numberOfBlocks)) {
52 | res.status(403);
53 | res.json({success: false, err: 'Specify from, to, amount, remainder, remainder, numberOfChains and numberOfBlocks'});
54 | } else {
55 | const tx = new Transaction(req.body.from, req.body.to, req.body.amount, req.body.remainder, req.body.numberOfChains, req.body.numberOfBlocks);
56 | app.transactionList.addTransaction(tx);
57 | updateSseClients();
58 | res.json({success: true});
59 | }
60 | });
61 |
62 | router.post('/register-transactions', (req, res) => {
63 | if(!isPresent(req.body.transactions)) {
64 | res.status(403);
65 | res.json({success: false, err: 'Specify array of transactions'});
66 | } else {
67 | req.body.transactions.forEach(tx => {
68 | app.transactionList.addTransaction(new Transaction(tx.from, tx.to, tx.amount, tx.remainder, tx.numberOfChains, tx.numberOfBlocks));
69 | });
70 | updateSseClients();
71 | res.json({success: true});
72 | }
73 | });
74 |
75 | /**
76 | * Update the running status of a node.
77 | */
78 | router.post('/set-node-status', (req, res) => {
79 | if(!isPresent(req.body.id) || !isPresent(req.body.running)) {
80 | res.status(403);
81 | res.json({success: false, err: 'Specify node ID and running status'});
82 | } else {
83 | app.nodeList.setNodeStatus(req.body.id, req.body.running);
84 | res.json({success: true, id: req.body.id});
85 | }
86 | });
87 |
88 | /**
89 | * Gets a specific node. Getter body should contain id.
90 | */
91 | router.get('/node', (req, res) => {
92 | if(!isPresent(req.body.id)) {
93 | res.status(403);
94 | res.json({success: false, err: 'Specify id'});
95 | } else {
96 | const node = app.nodeList.getNode(req.body.id);
97 | if (node == null) {
98 | res.status(403);
99 | res.json({success: false, err: 'invalid id or uninitialized node'});
100 | } else {
101 | res.json({success: true, node: node});
102 | }
103 | }
104 | });
105 |
106 | router.get('/demo', (req, res) => {
107 | res.render('demo');
108 | });
109 |
110 | /**
111 | * Reset the nodelist on the tracker server.
112 | */
113 | router.post('/reset', (req, res) => {
114 | app.nodeList = new NodeList();
115 | app.transactionList = new TransactionList();
116 | res.json({success: true});
117 | initDataHeartbeat();
118 | });
119 |
120 | /**
121 | * Get the number of currently registered nodes and currently running nodes on the tracker server.
122 | */
123 | router.get('/status', (req, res) => {
124 | res.json({registered: app.nodeList.getSize(), running: app.nodeList.getRunning()});
125 | });
126 |
127 | function isPresent(arg) {
128 | return !!(arg || arg === 0 || arg === "" || arg === false);
129 | }
130 |
131 | /////////////////////////// TOPN stuff //////////////////////////
132 |
133 | const sseClients = new sseMW.Topic();
134 | // initial registration of SSE Client Connection
135 | router.get('/topn/updates', function(req,res){
136 | const sseConnection = res.sseConnection;
137 | sseConnection.setup();
138 | sseClients.add(sseConnection);
139 | } );
140 |
141 | /**
142 | * send message to all registered SSE clients
143 | */
144 | function updateSseClients() {
145 | const nodes = app.nodeList.getGraphNodes();
146 | const edges = app.transactionList.getGraphEdges();
147 | sseClients.forEach(sseConnection => sseConnection.send(
148 | {nodes: nodes, edges: edges, numbers: app.transactionList.getNumbers()}));
149 | }
150 |
151 | function initDataHeartbeat() {
152 | setInterval(() => {
153 | app.transactionList.addNumbersToArray();
154 | }, 5000);
155 | }
156 |
157 | /**
158 | * Write all data.
159 | */
160 | router.post('/write-data', (req, res) => {
161 | const createCsvWriter = require('csv-writer').createObjectCsvWriter;
162 | const csvWriter = createCsvWriter({
163 | path: './data.csv',
164 | header: [
165 | {id: 'numberOfTransactions', title:'numberOfTransactions'},
166 | {id: 'averageNumberOfBlocks', title:'averageNumberOfBlocks'},
167 | {id: 'averageNumberOfChains', title:'averageNumberOfChains'}
168 | ]
169 | });
170 | fs.writeFile('./nodelist.json', JSON.stringify(app.nodeList, null, 2) , 'utf-8');
171 | fs.writeFile('./transactionlist.json', JSON.stringify(app.transactionList, null, 2) , 'utf-8');
172 | csvWriter.writeRecords(app.transactionList.getNumbersArray()).then(() => {
173 | console.log("Writing to csv done!");
174 | res.json(app.transactionList.getNumbersArray());
175 | });
176 | });
177 |
178 | /**
179 | * send a heartbeat signal to all SSE clients, once every interval seconds (or every 3 seconds if no interval is specified)
180 | * @param interval - interval in seconds
181 | */
182 | function initHeartbeat(interval) {
183 | setInterval(() => {
184 | const msg = {"label":"The latest", "time":new Date()};
185 | updateSseClients( JSON.stringify(msg));
186 | }, interval?interval*1000:3000);
187 | }
188 | // initialize heartbeat at 10 second interval
189 | initHeartbeat(10);
190 |
191 | export default router;
192 |
--------------------------------------------------------------------------------
/tracker-server/views/demo.ejs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
20 |
21 |
22 |
23 | Scale-Out Distributed Ledger
24 |
25 |
26 | | Total #transactions |
27 | Average #chains per proof |
28 | Average #blocks per proof |
29 |
30 |
31 |
|
32 |
|
33 |
|
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
46 |
--------------------------------------------------------------------------------