(#1457)
+- Feature: Doclet annotations (#1155)
+- Fix: fixes spent states of addresses not getting persisted on tx pruning (#1437)
+- Change: Made API class easier to work with
+- Fix: add boolean values to configurations for regression tests
+- Fix: Boolean flag consistent usage (#1295)
+- Feature: Do not request one transaction at a time (#1311)
+- Fix: log inconsistent addresses in debug mode (#1347)
+- Feature: Use xxHash instead of SHA-256 on incoming transaction hashes cache (#1326)
+- Feature: Added iotacafe/maven and iotacafe/java container full digest with sha256 in Dockerfile's FROM directives. (#1259)
+- Feature: Introducing a Cuckoo Filter for local snapshots (#1100)
+- Change: Prepare IRI to have its version injected by CI (#1359)
+- Change: print out line number in log info. (#1362)
+- Feature: Add configuration parameter for remote trusted api hosts (#1203)
+- Feature: upgrade RocksDB to version 5.17.2 (#1206)
+- Fix: unknown IXI command response (#1327)
+- Documentation: readme links fix (#1355)
+- Fix: ZMQ publishes to TCP and IPC instead of just one of them
+
1.7.0
- refactor milestone signature parameters to be configurable (#1322)
- migration from legacy coordinator to compass
diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
index 0fbf491c42..1f56059e0f 100755
--- a/docker/entrypoint.sh
+++ b/docker/entrypoint.sh
@@ -11,5 +11,5 @@ exec java \
-Xmx$JAVA_MAX_MEMORY \
-Djava.net.preferIPv4Stack=true \
-jar $DOCKER_IRI_JAR_PATH \
- --remote --remote-limit-api "$DOCKER_IRI_REMOTE_LIMIT_API" \
+ --remote true --remote-limit-api "$DOCKER_IRI_REMOTE_LIMIT_API" \
"$@"
diff --git a/pom.xml b/pom.xml
index 7edc71d4bc..41bd2ac3bd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
* Validation of a transaction is the process by which other devices choose the transaction.
* This is done via a {@link TipSelector} algorithm, after which the transaction performs
- * the necessary proof-of-work in order to cast their vote of confirmation/approval upon those tips.
* As many other transactions repeat this process on top of each other,
* validation of the transaction in question slowly builds up enough verifications.
* Eventually this will reach a minimum acceptable verification threshold.
@@ -106,7 +107,6 @@ public class Iota {
public final Replicator replicator;
public final IotaConfig configuration;
public final TipsViewModel tipsViewModel;
- public final MessageQ messageQ;
public final TipSelector tipsSelector;
/**
@@ -141,12 +141,11 @@ public Iota(IotaConfig configuration) throws TransactionPruningException, Snapsh
// legacy code
bundleValidator = new BundleValidator();
tangle = new Tangle();
- messageQ = MessageQ.createWith(configuration);
tipsViewModel = new TipsViewModel();
- transactionRequester = new TransactionRequester(tangle, snapshotProvider, messageQ);
+ transactionRequester = new TransactionRequester(tangle, snapshotProvider);
transactionValidator = new TransactionValidator(tangle, snapshotProvider, tipsViewModel, transactionRequester);
node = new Node(tangle, snapshotProvider, transactionValidator, transactionRequester, tipsViewModel,
- latestMilestoneTracker, messageQ, configuration);
+ latestMilestoneTracker, configuration);
replicator = new Replicator(node, configuration);
udpReceiver = new UDPReceiver(node, configuration);
tipsSolidifier = new TipsSolidifier(tangle, transactionValidator, tipsViewModel, configuration);
@@ -156,8 +155,10 @@ public Iota(IotaConfig configuration) throws TransactionPruningException, Snapsh
}
/**
+ *
* Adds all database providers, and starts initialization of our services.
- * According to the {@link IotaConfig}, data is optionally cleared, reprocessed and reverified.
* Creates a background worker that tries to work through the request queue by sending random tips along the requested
- * transactions.
* This massively increases the sync speed of new nodes that would otherwise be limited to requesting in the same rate
- * as new transactions are received.
* Creates a background worker that tries to work through the request queue by sending random tips along the requested
- * transactions.
* This massively increases the sync speed of new nodes that would otherwise be limited to requesting in the same rate
- * as new transactions are received.
+ * Initializes the instance and registers its dependencies.
+ * It simply stores the passed in values in their corresponding private properties.
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
* To reduce the overhead for the node we only trigger this worker if the request queue gets bigger than the {@link
* #REQUESTER_THREAD_ACTIVATION_THRESHOLD}. Otherwise we rely on the processing of the queue due to normal outgoing
- * traffic like transactions that get relayed by our node.
+ * Retrieves a random solid tip that can be sent together with our request.
+ * true
+ *
+ * @param args the list of program startup arguments
+ * @return true if this is testnet, otherwise false
+ */
+ private static boolean isTestnet(String[] args) {
+ int index = ArrayUtils.indexOf(args, Config.TESTNET_FLAG);
+ if (index != -1 && args.length > index+1) {
+ Boolean bool = BooleanUtils.toBooleanObject(args[index+1]);
+ return bool == null ? false : bool;
+ }
+
+ return false;
+ }
+
/**
* Parses the command line arguments for a config file that can be provided by parameter -c
* or parameter --config. If no filename was provided we fall back to iota.ini file.
diff --git a/src/main/java/com/iota/iri/IXI.java b/src/main/java/com/iota/iri/IXI.java
index 94b7e9ff79..05d4f3c79a 100644
--- a/src/main/java/com/iota/iri/IXI.java
+++ b/src/main/java/com/iota/iri/IXI.java
@@ -196,7 +196,7 @@ public AbstractResponse processCommand(final String command, Map
- *
+ * the necessary proof-of-work in order to cast their vote of confirmation/approval upon those tips.
+ *
+ * According to the {@link IotaConfig}, data is optionally cleared, reprocessed and reverified.
+ * java iri.jar --help at the command line.
+ */
interface Descriptions {
String PORT = "The port that will be used by the API.";
String API_HOST = "The host on which the API will listen to. Set to 0.0.0.0 to accept any host.";
String REMOTE_LIMIT_API = "Commands that should be ignored by API.";
- String REMOTE_AUTH = "A string in the form of
+ * used in this class.
*
* @param transactionViewModel the transaction that shall be sent
* @param neighbor the neighbor that should receive the packet
@@ -655,7 +648,7 @@ private Runnable spawnTipRequesterThread() {
long now = System.currentTimeMillis();
if ((now - lastTime) > 10000L) {
lastTime = now;
- messageQ.publish("rstat %d %d %d %d %d",
+ tangle.publish("rstat %d %d %d %d %d",
getReceiveQueueSize(), getBroadcastQueueSize(),
transactionRequester.numberOfTransactionsToRequest(), getReplyQueueSize(),
TransactionViewModel.getNumberOfStoredTransactions(tangle));
@@ -771,10 +764,8 @@ public void shutdown() throws InterruptedException {
executor.awaitTermination(6, TimeUnit.SECONDS);
}
- private ByteBuffer getBytesDigest(byte[] receivedData) throws NoSuchAlgorithmException {
- MessageDigest digest = MessageDigest.getInstance("SHA-256");
- digest.update(receivedData, 0, TransactionViewModel.SIZE);
- return ByteBuffer.wrap(digest.digest());
+ private long getBytesDigest(byte[] receivedData) {
+ return recentSeenBytesHashFunction.hashBytes(receivedData, 0, TransactionViewModel.SIZE);
}
// helpers methods
@@ -837,7 +828,7 @@ private void parseNeighborsConfig() {
.map(u -> newNeighbor(u, true))
.peek(u -> {
log.info("-> Adding neighbor : {} ", u.getAddress());
- messageQ.publish("-> Adding Neighbor : %s", u.getAddress());
+ tangle.publish("-> Adding Neighbor : %s", u.getAddress());
}).forEach(neighbors::add);
}
diff --git a/src/main/java/com/iota/iri/network/TransactionRequester.java b/src/main/java/com/iota/iri/network/TransactionRequester.java
index 1b846d345f..5f0873fd68 100644
--- a/src/main/java/com/iota/iri/network/TransactionRequester.java
+++ b/src/main/java/com/iota/iri/network/TransactionRequester.java
@@ -1,9 +1,10 @@
package com.iota.iri.network;
+import com.google.common.annotations.VisibleForTesting;
import com.iota.iri.controllers.TransactionViewModel;
import com.iota.iri.model.Hash;
+import com.iota.iri.service.snapshot.Snapshot;
import com.iota.iri.service.snapshot.SnapshotProvider;
-import com.iota.iri.zmq.MessageQ;
import com.iota.iri.storage.Tangle;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
@@ -18,7 +19,6 @@
public class TransactionRequester {
private static final Logger log = LoggerFactory.getLogger(TransactionRequester.class);
- private final MessageQ messageQ;
private final Set
- *
+ * transactions.
+ *
+ * as new transactions are received.
+ *
+ * Works through the request queue by sending a request alongside a random tip to each of our neighbors.
+ *
* @return true when we have send the request to our neighbors, otherwise false
*/
boolean processRequestQueue();
/**
* Starts the background worker that automatically calls {@link #processRequestQueue()} periodically to process the
- * requests in the queue.
+ * requests in the queue.
*/
void start();
/**
- * Stops the background worker that automatically works through the request queue.
+ * Stops the background worker that automatically works through the request queue.
*/
void shutdown();
}
diff --git a/src/main/java/com/iota/iri/network/impl/TransactionRequesterWorkerImpl.java b/src/main/java/com/iota/iri/network/impl/TransactionRequesterWorkerImpl.java
index e3d6ea3bb6..18b403ad69 100644
--- a/src/main/java/com/iota/iri/network/impl/TransactionRequesterWorkerImpl.java
+++ b/src/main/java/com/iota/iri/network/impl/TransactionRequesterWorkerImpl.java
@@ -1,5 +1,6 @@
package com.iota.iri.network.impl;
+import com.google.common.annotations.VisibleForTesting;
import com.iota.iri.controllers.TipsViewModel;
import com.iota.iri.controllers.TransactionViewModel;
import com.iota.iri.model.Hash;
@@ -16,39 +17,41 @@
import java.util.concurrent.TimeUnit;
/**
+ *
- *
+ * transactions.
+ *
- *
+ * as new transactions are received.
+ *
+ * outgoing traffic like transactions that get relayed by our node.
*/
public class TransactionRequesterWorkerImpl implements TransactionRequesterWorker {
/**
- * The minimum amount of transactions in the request queue that are required for the worker to trigger.
+ * The minimum amount of transactions in the request queue that are required for the worker to trigger.
*/
public static final int REQUESTER_THREAD_ACTIVATION_THRESHOLD = 50;
/**
- * The time (in milliseconds) that the worker waits between its iterations.
+ * The time (in milliseconds) that the worker waits between its iterations.
*/
private static final int REQUESTER_THREAD_INTERVAL = 100;
/**
- * The logger of this class (a rate limited logger than doesn't spam the CLI output).
+ * The logger of this class (a rate limited logger than doesn't spam the CLI output).
*/
private static final Logger log = LoggerFactory.getLogger(TransactionRequesterWorkerImpl.class);
/**
- * The Tangle object which acts as a database interface.
+ * The Tangle object which acts as a database interface.
*/
private Tangle tangle;
/**
- * The manager for the requested transactions that allows us to access the request queue.
+ * The manager for the requested transactions that allows us to access the request queue.
*/
private TransactionRequester transactionRequester;
@@ -58,26 +61,27 @@ public class TransactionRequesterWorkerImpl implements TransactionRequesterWorke
private TipsViewModel tipsViewModel;
/**
- * The network manager of the node.
+ * The network manager of the node.
*/
private Node node;
/**
- * The manager of the background task.
+ * The manager of the background task.
*/
private final SilentScheduledExecutorService executorService = new DedicatedScheduledExecutorService(
"Transaction Requester", log);
/**
- * Initializes the instance and registers its dependencies.
- *
- * It simply stores the passed in values in their corresponding private properties.
- *
+ *
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
+ *
+ * traffic like transactions that get relayed by our node.
+ *
- *
- * It simply retrieves the hash of the tip from the {@link #tipsViewModel} and tries to load it from the
- * database.
+ *
* The API makes it possible to interact with the node by requesting information or actions to be taken.
@@ -76,221 +68,150 @@
@SuppressWarnings("unchecked")
public class API {
+ private static final Logger log = LoggerFactory.getLogger(API.class);
+
+ //region [CONSTANTS] ///////////////////////////////////////////////////////////////////////////////
+
public static final String REFERENCE_TRANSACTION_NOT_FOUND = "reference transaction not found";
public static final String REFERENCE_TRANSACTION_TOO_OLD = "reference transaction is too old";
public static final String INVALID_SUBTANGLE = "This operation cannot be executed: "
+ "The subtangle has not been updated yet.";
+
+ private static final String OVER_MAX_ERROR_MESSAGE = "Could not complete request";
+ private static final String INVALID_PARAMS = "Invalid parameters";
- private static final Logger log = LoggerFactory.getLogger(API.class);
- private final IXI ixi;
-
- private Undertow server;
-
- private final Gson gson = new GsonBuilder().create();
- private volatile PearlDiver pearlDiver = new PearlDiver();
-
- private final AtomicInteger counter = new AtomicInteger(0);
-
- private Pattern trytesPattern = Pattern.compile("[9A-Z]*");
+ private static final char ZERO_LENGTH_ALLOWED = 'Y';
+ private static final char ZERO_LENGTH_NOT_ALLOWED = 'N';
+
+ private static final int HASH_SIZE = 81;
+ private static final int TRYTES_SIZE = 2673;
- private final static int HASH_SIZE = 81;
- private final static int TRYTES_SIZE = 2673;
-
- private final static long MAX_TIMESTAMP_VALUE = (long) (Math.pow(3, 27) - 1) / 2; // max positive 27-trits value
+ private static final long MAX_TIMESTAMP_VALUE = (long) (Math.pow(3, 27) - 1) / 2; // max positive 27-trits value
+ //endregion ////////////////////////////////////////////////////////////////////////////////////////////////////////
+
private static int counterGetTxToApprove = 0;
private static long ellapsedTime_getTxToApprove = 0L;
private static int counter_PoW = 0;
private static long ellapsedTime_PoW = 0L;
+
+ //region [CONSTRUCTOR_FIELDS] ///////////////////////////////////////////////////////////////////////////////
+ private final IotaConfig configuration;
+ private final IXI ixi;
+ private final TransactionRequester transactionRequester;
+ private final SpentAddressesService spentAddressesService;
+ private final Tangle tangle;
+ private final BundleValidator bundleValidator;
+ private final SnapshotProvider snapshotProvider;
+ private final LedgerService ledgerService;
+ private final Node node;
+ private final TipSelector tipsSelector;
+ private final TipsViewModel tipsViewModel;
+ private final TransactionValidator transactionValidator;
+ private final LatestMilestoneTracker latestMilestoneTracker;
+
private final int maxFindTxs;
private final int maxRequestList;
private final int maxGetTrytes;
- private final int maxBodyLength;
- private final boolean testNet;
- private final static String overMaxErrorMessage = "Could not complete request";
- private final static String invalidParams = "Invalid parameters";
+ private final String[] features;
+
+ //endregion ////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ private final Gson gson = new GsonBuilder().create();
+ private volatile PearlDiver pearlDiver = new PearlDiver();
- private final static char ZERO_LENGTH_ALLOWED = 'Y';
- private final static char ZERO_LENGTH_NOT_ALLOWED = 'N';
- private Iota instance;
+ private final AtomicInteger counter = new AtomicInteger(0);
- private final String[] features;
+ private Pattern trytesPattern = Pattern.compile("[9A-Z]*");
+
+ //Package Private For Testing
+ final Map
- * Processes an API HTTP request.
- * No checks have been done until now, except that it is not an OPTIONS request.
- * We can be sure that we are in a thread that allows blocking.
- *
- * The request process duration is recorded.
- * During this the request gets verified. If it is incorrect, an {@link ErrorResponse} is made.
- * Otherwise it is processed in {@link #process(String, InetSocketAddress)}.
- * The result is sent back to the requester.
- *
- * Handles statistics on tip selection.
- * Increases the tip selection by one use.
- *
- *
- */
- public void init() throws IOException {
- APIConfig configuration = instance.configuration;
- final int apiPort = configuration.getPort();
- final String apiHost = configuration.getApiHost();
-
- log.debug("Binding JSON-REST API Undertow server on {}:{}", apiHost, apiPort);
-
- server = Undertow.builder().addHttpListener(apiPort, apiHost)
- .setHandler(path().addPrefixPath("/", addSecurity(new HttpHandler() {
- @Override
- public void handleRequest(final HttpServerExchange exchange) throws Exception {
- HttpString requestMethod = exchange.getRequestMethod();
- if (Methods.OPTIONS.equals(requestMethod)) {
- String allowedMethods = "GET,HEAD,POST,PUT,DELETE,TRACE,OPTIONS,CONNECT,PATCH";
- //return list of allowed methods in response headers
- exchange.setStatusCode(StatusCodes.OK);
- exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, MimeMappings.DEFAULT_MIME_MAPPINGS.get("txt"));
- exchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, 0);
- exchange.getResponseHeaders().put(Headers.ALLOW, allowedMethods);
- exchange.getResponseHeaders().put(new HttpString("Access-Control-Allow-Origin"), "*");
- exchange.getResponseHeaders().put(new HttpString("Access-Control-Allow-Headers"), "User-Agent, Origin, X-Requested-With, Content-Type, Accept, X-IOTA-API-Version");
- exchange.getResponseSender().close();
- return;
- }
- if (exchange.isInIoThread()) {
- exchange.dispatch(this);
- return;
- }
- processRequest(exchange);
- }
- }))).build();
- server.start();
- }
-
- /**
- * Sends the API response back as JSON to the requester.
- * Status code of the HTTP request is also set according to the type of response.
- *
- *
- *
- * @param exchange Contains information about what the client sent to us
- * @param res The response of the API.
- * See {@link #processRequest(HttpServerExchange)}
- * and {@link #process(String, InetSocketAddress)} for the different responses in each case.
- * @param beginningTime The time when we received the request, in milliseconds.
- * This will be used to set the response duration in {@link AbstractResponse#setDuration(Integer)}
- * @throws IOException When connection to client has been lost - Currently being caught.
- */
- private void sendResponse(HttpServerExchange exchange, AbstractResponse res, long beginningTime) throws IOException {
- res.setDuration((int) (System.currentTimeMillis() - beginningTime));
- final String response = gson.toJson(res);
-
- if (res instanceof ErrorResponse) {
- // bad request or invalid parameters
- exchange.setStatusCode(400);
- } else if (res instanceof AccessLimitedResponse) {
- // API method not allowed
- exchange.setStatusCode(401);
- } else if (res instanceof ExceptionResponse) {
- // internal error
- exchange.setStatusCode(500);
- }
-
- setupResponseHeaders(exchange);
-
- ByteBuffer responseBuf = ByteBuffer.wrap(response.getBytes(StandardCharsets.UTF_8));
- exchange.setResponseContentLength(responseBuf.array().length);
- StreamSinkChannel sinkChannel = exchange.getResponseChannel();
- sinkChannel.getWriteSetter().set( channel -> {
- if (responseBuf.remaining() > 0) {
- try {
- sinkChannel.write(responseBuf);
- if (responseBuf.remaining() == 0) {
- exchange.endExchange();
- }
- } catch (IOException e) {
- log.error("Lost connection to client - cannot send response");
- exchange.endExchange();
- sinkChannel.getWriteSetter().set(null);
- }
- }
- else {
- exchange.endExchange();
- }
- });
- sinkChannel.resumeWrites();
+ features = Feature.calculateFeatureNames(configuration);
+
+ commandRoute = new HashMap<>();
+ commandRoute.put(ApiCommand.ADD_NEIGHBORS, addNeighbors());
+ commandRoute.put(ApiCommand.ATTACH_TO_TANGLE, attachToTangle());
+ commandRoute.put(ApiCommand.BROADCAST_TRANSACTIONs, broadcastTransactions());
+ commandRoute.put(ApiCommand.FIND_TRANSACTIONS, findTransactions());
+ commandRoute.put(ApiCommand.GET_BALANCES, getBalances());
+ commandRoute.put(ApiCommand.GET_INCLUSION_STATES, getInclusionStates());
+ commandRoute.put(ApiCommand.GET_NEIGHBORS, getNeighbors());
+ commandRoute.put(ApiCommand.GET_NODE_INFO, getNodeInfo());
+ commandRoute.put(ApiCommand.GET_NODE_API_CONFIG, getNodeAPIConfiguration());
+ commandRoute.put(ApiCommand.GET_TIPS, getTips());
+ commandRoute.put(ApiCommand.GET_TRANSACTIONS_TO_APPROVE, getTransactionsToApprove());
+ commandRoute.put(ApiCommand.GET_TRYTES, getTrytes());
+ commandRoute.put(ApiCommand.INTERRUPT_ATTACHING_TO_TANGLE, interruptAttachingToTangle());
+ commandRoute.put(ApiCommand.REMOVE_NEIGHBORS, removeNeighbors());
+ commandRoute.put(ApiCommand.STORE_TRANSACTIONS, storeTransactions());
+ commandRoute.put(ApiCommand.GET_MISSING_TRANSACTIONS, getMissingTransactions());
+ commandRoute.put(ApiCommand.CHECK_CONSISTENCY, checkConsistency());
+ commandRoute.put(ApiCommand.WERE_ADDRESSES_SPENT_FROM, wereAddressesSpentFrom());
}
/**
- *
- *
*
* If a transaction does not exist, or it is not a tail, an {@link ErrorResponse} is returned.
@@ -566,6 +371,7 @@ private Hash findTail(Hash hash) throws Exception {
* @param transactionsList Transactions you want to check the consistency for
* @return {@link CheckConsistency}
**/
+ @Document(name="checkConsistency")
private AbstractResponse checkConsistencyStatement(List
- * If the {@link #getCounterGetTxToApprove()} is a power of 100, a log is send and counters are reset. + * If the {@link #getCounterGetTxToApprove()} is a power of 100, a log is send and counters are reset. *
*/ private void gatherStatisticsOnTipSelection() { @@ -826,8 +645,9 @@ private void gatherStatisticsOnTipSelection() { * * @return {@link com.iota.iri.service.dto.GetTipsResponse} **/ + @Document(name="getTips") private synchronized AbstractResponse getTipsStatement() throws Exception { - return GetTipsResponse.create(instance.tipsViewModel.getTips() + return GetTipsResponse.create(tipsViewModel.getTips() .stream() .map(Hash::toString) .collect(Collectors.toList())); @@ -839,28 +659,32 @@ private synchronized AbstractResponse getTipsStatement() throws Exception { * These trytes are returned by attachToTangle, or by doing proof of work somewhere else. * * @param trytes Transaction data to be stored. + * @return {@link com.iota.iri.service.dto.AbstractResponse.Emptyness} * @throws Exception When storing or updating a transaction fails. **/ - public void storeTransactionsStatement(List- * Get the inclusion states of a set of transactions. - * This is for determining if a transaction was accepted and confirmed by the network or not. - * You can search for multiple tips (and thus, milestones) to get past inclusion states of transactions. + * Get the inclusion states of a set of transactions. + * This endpoint determines if a transaction is confirmed by the network (referenced by a valid milestone). + * You can search for multiple tips (and thus, milestones) to get past inclusion states of transactions. *
*
- * This API call returns a list of boolean values in the same order as the submitted transactions.
- * Boolean values will be true for confirmed transactions, otherwise false.
+ * This API call returns a list of boolean values in the same order as the submitted transactions.
+ * Boolean values will be true for confirmed transactions, otherwise false.
*
- * Find the transactions which match the specified input and return. - * All input values are lists, for which a list of return values (transaction hashes), in the same order, is returned for all individual elements. - * The input fields can either be bundles, addresses, tags or approvees. + * Find transactions that contain the given values in their transaction fields. + * All input values are lists, for which a list of return values (transaction hashes), in the same order, is returned for all individual elements. + * The input fields can either be bundles, addresses, tags or approvees. *
* - * Using multiple of these input fields returns the intersection of the values. - * Returns an {@link com.iota.iri.service.dto.ErrorResponse} if more than maxFindTxs was found. + * Using multiple transaction fields returns transactions hashes at the intersection of those values. * * @param request The map with input fields * Must contain at least one of 'bundles', 'addresses', 'tags' or 'approvees'. @@ -1119,6 +945,7 @@ private boolean exhaustiveSearchWithinIndex( * @throws Exception If a model cannot be loaded, no valid input fields were supplied * or the total transactions to find exceeds {@link APIConfig#getMaxFindTransactions()}. **/ + @Document(name="findTransactions") private synchronized AbstractResponse findTransactionsStatement(final Map- * Calculates the confirmed balance, as viewed by the specified tips. - * If you do not specify the referencing tips, - * the returned balance is based on the latest confirmed milestone. - * In addition to the balances, it also returns the referencing tips (or milestone), - * as well as the index with which the confirmed balance was determined. - * The balances are returned as a list in the same order as the addresses were provided as input. + * Calculates the confirmed balance, as viewed by the specified tips. + * If the tips parameter is missing, the returned balance is correct as of the latest confirmed milestone. + * In addition to the balances, it also returns the referencing tips (or milestone), + * as well as the index with which the confirmed balance was determined. + * The balances are returned as a list in the same order as the addresses were provided as input. *
- * Returns an {@link ErrorResponse} if tips are not found, inconsistent or the threshold is invalid. * - * @param addresses The addresses where we will find the balance for. + * @param addresses Address for which to get the balance (do not include the checksum) * @param tips The optional tips to find the balance through. * @param threshold The confirmation threshold between 0 and 100(inclusive). * Should be set to 100 for getting balance by counting only confirmed transactions. * @return {@link com.iota.iri.service.dto.GetBalancesResponse} * @throws Exception When the database has encountered an error **/ - private AbstractResponse getBalancesStatement(List- * Prepares the specified transactions (trytes) for attachment to the Tangle by doing Proof of Work. - * You need to supply branchTransaction as well as trunkTransaction. - * These are the tips which you're going to validate and reference with this transaction. - * These are obtainable by the getTransactionsToApprove API call. + * Prepares the specified transactions (trytes) for attachment to the Tangle by doing Proof of Work. + * You need to supply branchTransaction as well as trunkTransaction. + * These are the tips which you're going to validate and reference with this transaction. + * These are obtainable by the getTransactionsToApprove API call. *
*- * The returned value is a different set of tryte values which you can input into - * broadcastTransactions and storeTransactions. - * The last 243 trytes of the return value consist of the following: - *
trunkTransactionbranchTransactionnoncetrunkTransactionbranchTransactionnoncenull
+ */
+ public static ApiCommand findByName(String name) {
+ for (ApiCommand c : values()) {
+ if (c.toString().equals(name)) {
+ return c;
+ }
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/com/iota/iri/service/ValidationException.java b/src/main/java/com/iota/iri/service/ValidationException.java
index a71ef6d4f1..0d169d290a 100644
--- a/src/main/java/com/iota/iri/service/ValidationException.java
+++ b/src/main/java/com/iota/iri/service/ValidationException.java
@@ -1,6 +1,6 @@
package com.iota.iri.service;
-public class ValidationException extends Exception {
+public class ValidationException extends RuntimeException {
/**
* Initializes a new instance of the ValidationException.
diff --git a/src/main/java/com/iota/iri/service/dto/AbstractResponse.java b/src/main/java/com/iota/iri/service/dto/AbstractResponse.java
index 382d8f5bcb..c5f98c3086 100644
--- a/src/main/java/com/iota/iri/service/dto/AbstractResponse.java
+++ b/src/main/java/com/iota/iri/service/dto/AbstractResponse.java
@@ -7,7 +7,8 @@
/**
*
- * Every response that the IRI API gives is a child of this class.bundles: returns the list of transactions which contain the specified bundle hash.
- * addresses: returns the list of transactions which have the specified address as an input/output field.
- * tags: returns the list of transactions which contain the specified tag value.
- * approvees: returns the list of transactions which reference (i.e. approve) the specified transaction.
+ * bundles: returns an array of transaction hashes that contain the given bundle hash.addresses: returns an array of transaction hashes that contain the given address in the `address` field.tags: returns an array of transaction hashes that contain the given value in the `tag` field.approvees: returns an array of transaction hashes that contain the given transactions in their `branchTransaction` or `trunkTransaction` fields.
* Represents the service that contains all the relevant business logic for modifying and calculating the ledger
- * state.
- *
- * This class is stateless and does not hold any domain specific models.
+ * state.
+ *
* Restores the ledger state after a restart of IRI, which allows us to fast forward to the point where we
- * stopped before the restart.
- *
+ * stopped before the restart.
+ *
* It looks for the last solid milestone that was applied to the ledger in the database and then replays all
* milestones leading up to this point by applying them to the latest snapshot. We do not check every single
* milestone again but assume that the data in the database is correct. If the database would have any
* inconsistencies and the application fails, the latest solid milestone tracker will check and apply the milestones
- * one by one and repair the corresponding inconsistencies.
+ * one by one and repair the corresponding inconsistencies.
+ *
+ * Applies the given milestone to the ledger state. + *
+ *
* It first marks the transactions that were confirmed by this milestones as confirmed by setting their
* corresponding {@code snapshotIndex} value. Then it generates the {@link com.iota.iri.model.StateDiff} that
- * reflects the accumulated balance changes of all these transactions and applies it to the latest Snapshot.
+ * reflects the accumulated balance changes of all these transactions and applies it to the latest Snapshot.
+ *
+ * Checks the consistency of the combined balance changes of the given tips. + *
+ *
* It simply calculates the balance changes of the tips and then combines them to verify that they are leading to a
* consistent ledger state (which means that they are not containing any double-spends or spends of non-existent
- * IOTA).
+ * IOTA).
+ *
+ * Checks if the balance changes of the transactions that are referenced by the given tip are consistent. + *
+ *
* It first calculates the balance changes, then adds them to the given {@code diff} and finally checks their
* consistency. If we are only interested in the changes that are referenced by the given {@code tip} we need to
- * pass in an empty map for the {@code diff} parameter.
- *
+ * pass in an empty map for the {@code diff} parameter.
+ *
* The {@code diff} as well as the {@code approvedHashes} parameters are modified, so they will contain the new
- * balance changes and the approved transactions after this method terminates.
+ * balance changes and the approved transactions after this method terminates.
+ *
* Generates the accumulated balance changes of the transactions that are directly or indirectly referenced by the
* given transaction relative to the referenced milestone. Also persists the spent addresses that were found in the
- * process
- *
+ * process.
+ *
* It simply iterates over all approvees that have not been confirmed yet and that have not been processed already
- * (by being part of the {@code visitedNonMilestoneSubtangleHashes} set) and collects their balance changes.
+ * (by being part of the {@code visitedNonMilestoneSubtangleHashes} set) and collects their balance changes.
+ *
+ * Creates a service instance that allows us to perform ledger state specific operations. + *
+ *+ * This class is stateless and does not hold any domain specific models. + *
*/ public class LedgerServiceImpl implements LedgerService { /** - * Holds the tangle object which acts as a database interface.+ * Initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* Generates the {@link com.iota.iri.model.StateDiff} that belongs to the given milestone in the database and marks
* all transactions that have been approved by the milestone accordingly by setting their {@code snapshotIndex}
- * value.
- *
+ * value.
+ *
* It first checks if the {@code snapshotIndex} of the transaction belonging to the milestone was correctly set
* already (to determine if this milestone was processed already) and proceeds to generate the {@link
* com.iota.iri.model.StateDiff} if that is not the case. To do so, it calculates the balance changes, checks if
- * they are consistent and only then writes them to the database.
- *
+ * they are consistent and only then writes them to the database.
+ *
* If inconsistencies in the {@code snapshotIndex} are found it issues a reset of the corresponding milestone to
- * recover from this problem.
+ * recover from this problem.
+ *
* The manager that keeps track of the latest milestone by incorporating a background worker that periodically checks if
- * new milestones have arrived.
- *
+ * new milestones have arrived.
+ *
* Knowing about the latest milestone and being able to compare it to the latest solid milestone allows us to determine
- * if our node is "in sync".
+ * if our node is "in sync".
+ *
+ * Returns the index of the latest milestone that was seen by this tracker. + *
+ *+ * It returns the internal property that is used to store the latest milestone index. + *
* * @return the index of the latest milestone that was seen by this tracker */ int getLatestMilestoneIndex(); /** - * Returns the transaction hash of the latest milestone that was seen by this tracker.+ * Returns the transaction hash of the latest milestone that was seen by this tracker. + *
+ *+ * It returns the internal property that is used to store the latest milestone index. + *
* @return the transaction hash of the latest milestone that was seen by this tracker */ Hash getLatestMilestoneHash(); /** - * Sets the latest milestone.
+ * It stores the passed in values in their corresponding internal properties and can therefore be used to
* inform the {@link LatestSolidMilestoneTracker} about a new milestone. It is internally used to set the new
* milestone but can also be used by tests to mock a certain behaviour or in case we detect a new milestone in other
- * parts of the code.
+ * parts of the code.
+ *
* If the transaction that was analyzed represents a milestone, we check if it is younger than the current latest
- * milestone and update the internal properties accordingly.
+ * milestone and update the internal properties accordingly.
+ *
* Since the {@link LatestMilestoneTracker} scans all milestone candidates whenever IRI restarts, this flag gives us
- * the ability to determine if this initialization process has finished.
- *
+ * the ability to determine if this initialization process has finished.
+ *
* The values returned by {@link #getLatestMilestoneHash()} and {@link #getLatestMilestoneIndex()} will potentially
- * return wrong values until the scan has completed.
+ * return wrong values until the scan has completed.
+ *
* This interface defines the contract for the manager that keeps track of the latest solid milestone by incorporating a
- * background worker that periodically checks for new solid milestones.
- *
+ * background worker that periodically checks for new solid milestones.
+ *
* Whenever it finds a new solid milestone that hasn't been applied to the ledger state, yet it triggers the application
* logic which in return updates the {@link SnapshotProvider#getLatestSnapshot()}. Since the latest solid milestone is
* encoded in this latest snapshot of the node, this tracker does not introduce separate getters for the latest solid
- * milestone.
+ * milestone.
+ *
* This method searches for new solid milestones that follow the current latest solid milestone and that have not
- * been applied to the ledger state yet and applies them.
- *
+ * been applied to the ledger state yet and applies them.
+ *
* It takes care of applying the solid milestones in the correct order by only allowing solid milestones to be
- * applied that are directly following our current latest solid milestone.
+ * applied that are directly following our current latest solid milestone.
+ *
+ * Represents the service that contains all the relevant business logic for interacting with milestones. + *
+ * This class is stateless and does not hold any domain specific models. */ public interface MilestoneService { /** + *
* Finds the latest solid milestone that was previously processed by IRI (before a restart) by performing a search
- * in the database.
- *
+ * in the database.
+ *
* It determines if the milestones were processed by checking the {@code snapshotIndex} value of their corresponding
- * transactions.
- *
+ * transactions.
+ *
+ * Analyzes the given transaction to determine if it is a valid milestone. + *
+ * * It first checks if all transactions that belong to the milestone bundle are known already and only then verifies - * the signature to analyze if the given milestone was really issued by the coordinator.+ * Updates the milestone index of all transactions that belong to a milestone. + *
+ *
* It does that by iterating through all approvees of the milestone defined by the given {@code milestoneHash} until
* it reaches transactions that have been approved by a previous milestone. This means that this method only works
- * if the transactions belonging to the previous milestone have been updated already.
- *
+ * if the transactions belonging to the previous milestone have been updated already.
+ *
* While iterating through the transactions we also examine the milestone index that is currently set to detect
* corruptions in the database where a following milestone was processed before the current one. If such a
* corruption in the database is found we trigger a reset of the wrongly processed milestone to repair the ledger
- * state and recover from this error.
- *
+ * state and recover from this error.
+ *
* In addition to these checks we also update the solid entry points, if we detect that a transaction references a
* transaction that dates back before the last local snapshot (and that has not been marked as a solid entry point,
* yet). This allows us to handle back-referencing transactions and maintain local snapshot files that can always be
* used to bootstrap a node, even if the coordinator suddenly approves really old transactions (this only works
* if the transaction that got referenced is still "known" to the node by having a sufficiently high pruning
- * delay).
+ * delay).
+ *
* Resets all milestone related information of the transactions that were "confirmed" by the given milestone and
- * rolls back the ledger state to the moment before the milestone was applied.
- *
+ * rolls back the ledger state to the moment before the milestone was applied.
+ *
* This allows us to reprocess the milestone in case of errors where the given milestone could not be applied to the
* ledger state. It is for example used by the automatic repair routine of the {@link LatestSolidMilestoneTracker}
- * (to recover from inconsistencies due to crashes of IRI).
- *
+ * (to recover from inconsistencies due to crashes of IRI).
+ *
* It recursively resets additional milestones if inconsistencies are found within the resetted milestone (wrong
- * {@code milestoneIndex}es).
- *
+ * {@code milestoneIndex}es).
+ *
* Checks if the given transaction was confirmed by the milestone with the given index (or any of its
* predecessors).
- *
+ *
+ * Retrieves the milestone index of the given transaction by decoding the {@code OBSOLETE_TAG}. + *
+ *
* The returned result will of cause only have a reasonable value if we hand in a transaction that represents a real
- * milestone.
- *
+ * milestone.
+ *
+ * Attempts to retrieve the milestones that have been defined in the local snapshots file. + *
+ *
* The manager incorporates a background worker that proactively requests the missing milestones until all defined
* milestones are known. After all milestones have been retrieved the manager shuts down automatically (to free the
- * unused resources).
- *
+ * unused resources).
+ *
* Note: When we bootstrap a node with a local snapshot file, we are provided with a list of all seen milestones that
* were known during the creation of the snapshot. This list allows new nodes or nodes that start over with an
* empty database, to retrieve the missing milestones efficiently by directly requesting them from its neighbours
- * (without having to wait for them to be discovered during the solidification process).
- *
+ * (without having to wait for them to be discovered during the solidification process).
+ *
* This speeds up the sync-times massively and leads to nodes that are up within minutes rather than hours or even
- * days.
+ * days.
+ *
+ * Triggers the retrieval of the milestones by issuing transaction requests to the nodes neighbours. + *
+ *+ * It gets periodically called by the background worker to automatically retrieve all missing milestones. + *
*/ void retrieveSeenMilestones(); /** * Starts the background worker that automatically calls {@link #retrieveSeenMilestones()} - * periodically to retrieves all "seen" missing milestones.
* Creates a tracker that automatically detects new milestones by incorporating a background worker that periodically
* checks all transactions that are originating from the coordinator address and that exposes the found latest milestone
- * via getters.
- *
+ * via getters.
+ *
+ *
* It can be used to determine the sync-status of the node by comparing these values against the latest solid - * milestone.+ * This method initializes the instance and registers its dependencies. + *
+ *
* It simply stores the passed in values in their corresponding private properties and bootstraps the latest
- * milestone with values for the latest milestone that can be found quickly.
- *
+ * milestone with values for the latest milestone that can be found quickly.
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* In addition to setting the internal properties, we also issue a log message and publish the change to the ZeroMQ
- * message processor so external receivers get informed about this change.
+ * message processor so external receivers get informed about this change.
+ *
* We repeatedly call {@link #latestMilestoneTrackerThread()} to actively look for new milestones in our database.
* This is a bit inefficient and should at some point maybe be replaced with a check on transaction arrival, but
* this would required adjustments in the whole way IRI handles transactions and is therefore postponed for
- * now.
+ * now.
+ *
* This method contains the logic for scanning for new latest milestones that gets executed in a background
- * worker.
- *
+ * worker.
+ *
* It first collects all new milestone candidates that need to be analyzed, then analyzes them and finally checks if
* the initialization is complete. In addition to this scanning logic it also issues regular log messages about the
- * progress of the scanning.
+ * progress of the scanning.
+ *
+ * This method emits a log message about the scanning progress. + *
+ *
* It only emits a log message if we have more than one {@link #milestoneCandidatesToAnalyze}, which means that the
* very first call to this method in the "first run" on {@link #latestMilestoneTrackerThread()} will not produce any
* output (which is the reason why we call this method a second time after we have collected all the
- * candidates in the "first run").
+ * candidates in the "first run").
+ *
* This method collects the new milestones that have not been "seen" before, by collecting them in the {@link
- * #milestoneCandidatesToAnalyze} queue.
- *
+ * #milestoneCandidatesToAnalyze} queue.
+ *
* We simply request all transaction that are originating from the coordinator address and treat them as potential
- * milestone candidates.
+ * milestone candidates.
+ *
* This method analyzes the milestone candidates by working through the {@link #milestoneCandidatesToAnalyze}
- * queue.
- *
+ * queue.
+ *
* We only process {@link #MAX_CANDIDATES_TO_ANALYZE} at a time, to give the caller the option to terminate early
* and pick up new milestones as fast as possible without being stuck with analyzing the old ones for too
- * long.
+ * long.
+ *
+ * This method checks if the initialization is complete. + *
+ *
* It simply checks if the {@link #initialized} flag is not set yet and there are no more {@link
* #milestoneCandidatesToAnalyze}. If the initialization was complete, we issue a log message and set the
- * corresponding flag to {@code true}.
+ * corresponding flag to {@code true}.
+ *
* This method bootstraps this tracker with the latest milestone values that can easily be retrieved without
- * analyzing any transactions (for faster startup).
- *
+ * analyzing any transactions (for faster startup).
+ *
* It first sets the latest milestone to the values found in the latest snapshot and then check if there is a younger
* milestone at the end of our database. While this last entry in the database doesn't necessarily have to be the
- * latest one we know it at least gives a reasonable value most of the times.
+ * latest one we know it at least gives a reasonable value most of the times.
+ *
* Creates a manager that keeps track of the latest solid milestones and that triggers the application of these
* milestones and their corresponding balance changes to the latest {@link Snapshot} by incorporating a background
- * worker that periodically checks for new solid milestones.
- *
+ * worker that periodically checks for new solid milestones.
+ *
* It extends this with a mechanisms to recover from database corruptions by using a backoff strategy that reverts the
* changes introduced by previous milestones whenever an error is detected until the problem causing milestone was
- * found.
+ * found.
+ *
+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* In addition to applying the found milestones to the ledger state it also issues log messages and keeps the
- * {@link LatestMilestoneTracker} in sync (if we happen to process a new latest milestone faster).
+ * {@link LatestMilestoneTracker} in sync (if we happen to process a new latest milestone faster).
+ *
+ * Contains the logic for the background worker. + *
+ *
* It simply calls {@link #trackLatestSolidMilestone()} and wraps with a log handler that prevents the {@link
- * MilestoneException} to crash the worker.
+ * MilestoneException} to crash the worker.
+ *
+ * Applies the given milestone to the ledger. + *
+ *
* If the application of the milestone fails, we start a repair routine which will revert the milestones preceding
* our current milestone and consequently try to reapply them in the next iteration of the {@link
- * #trackLatestSolidMilestone()} method (until the problem is solved).
+ * #trackLatestSolidMilestone()} method (until the problem is solved).
+ *
+ * Checks if we are currently trying to repair a milestone. + *
+ *+ * We simply use the {@link #repairBackoffCounter} as an indicator if a repair routine is running. + *
* * @return {@code true} if we are trying to repair a milestone and {@code false} otherwise */ @@ -220,10 +229,13 @@ private boolean isRepairRunning() { } /** - * Checks if we successfully repaired the corrupted milestone.+ * Checks if we successfully repaired the corrupted milestone. + *
+ *
* To determine if the repair routine was successful we check if the processed milestone has a higher index than the
- * one that initially could not get applied to the ledger.
+ * one that initially could not get applied to the ledger.
+ *
+ * Resets the internal variables that are used to keep track of the repair process. + *
+ *
* It gets called whenever we advance to a milestone that has a higher milestone index than the milestone that
- * initially caused the repair routine to kick in (see {@link #repairCorruptedMilestone(MilestoneViewModel)}.
+ * initially caused the repair routine to kick in (see {@link #repairCorruptedMilestone(MilestoneViewModel)}.
+ *
+ * Keeps the {@link LatestMilestoneTracker} in sync with our current progress. + *
+ *
* Since the {@link LatestMilestoneTracker} scans all old milestones during its startup (which can take a while to
- * finish) it can happen that we see a newer latest milestone faster than this manager.
- *
+ * finish) it can happen that we see a newer latest milestone faster than this manager.
+ *
+ * Emits a log message whenever the latest solid milestone changes. + *
+ *
* It simply compares the current latest milestone index against the previous milestone index and emits the log
- * messages using the {@link #log} and the {@link #messageQ} instances if it differs.
+ * messages using the {@link #log} and the {@link #messageQ} instances if it differs.
+ *
+ * Tries to actively repair the ledger by reverting the milestones preceding the given milestone. + *
+ *
* It gets called when a milestone could not be applied to the ledger state because of problems like "inconsistent
* balances". While this should theoretically never happen (because milestones are by definition "consistent"), it
* can still happen because IRI crashed or got stopped in the middle of applying a milestone or if a milestone
- * was processed in the wrong order.
- *
+ * was processed in the wrong order.
+ *
* Every time we call this method the internal {@link #repairBackoffCounter} is incremented which causes the next
* call of this method to repair an additional milestone. This means that whenever we face an error we first try to
* reset only the last milestone, then the two last milestones, then the three last milestones (and so on ...) until
- * the problem was fixed.
- *
+ * the problem was fixed.
+ *
* To be able to tell when the problem is fixed and the {@link #repairBackoffCounter} can be reset, we store the
- * milestone index that caused the problem the first time we call this method.
+ * milestone index that caused the problem the first time we call this method.
+ *
+ * Creates a service instance that allows us to perform milestone specific operations. + *
+ *+ * This class is stateless and does not hold any domain specific models. + *
*/ public class MilestoneServiceImpl implements MilestoneService { /** - * Holds the logger of this class.+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* We first check the trivial case where the node was fully synced. If no processed solid milestone could be found
* within the last two milestones of the node, we perform a binary search from present to past, which reduces the
- * amount of database requests to a minimum (even with a huge amount of milestones in the database).
+ * amount of database requests to a minimum (even with a huge amount of milestones in the database).
+ *
* We redirect the call to {@link #resetCorruptedMilestone(int, Set)} while initiating the set of {@code
* processedTransactions} with an empty {@link HashSet} which will ensure that we reset all found
- * transactions.
+ * transactions.
+ *
* Performs a binary search for the latest solid milestone which was already processed by the node and applied to
- * the ledger state at some point in the past (i.e. before IRI got restarted).
- *
+ * the ledger state at some point in the past (i.e. before IRI got restarted).
+ *
* It searches from present to past using a binary search algorithm which quickly narrows down the amount of
- * candidates even for big databases.
+ * candidates even for big databases.
+ *
+ * Determines the milestone in the middle of the range defined by {@code rangeStart} and {@code rangeEnd}. + *
+ *
* It is used by the binary search algorithm of {@link #findLatestProcessedSolidMilestoneInDatabase()}. It first
* calculates the index that represents the middle of the range and then tries to find the milestone that is closest
- * to this index.
- *
+ * to this index.
+ *
+ * Checks if the milestone was applied to the ledger at some point in the past (before a restart of IRI). + *
+ *
* Since the {@code snapshotIndex} value is used as a flag to determine if the milestone was already applied to the
* ledger, we can use it to determine if it was processed by IRI in the past. If this value is set we should also
- * have a corresponding {@link StateDiff} entry in the database.
+ * have a corresponding {@link StateDiff} entry in the database.
+ *
+ * This method resets the {@code milestoneIndex} of a single transaction. + *
+ *
* In addition to setting the corresponding value, we also publish a message to the ZeroMQ message provider, which
- * allows external recipients to get informed about this change.
- *
+ * allows external recipients to get informed about this change.
+ *
* This method prepares the update of the milestone index by checking the current {@code snapshotIndex} of the given
- * transaction.
- *
+ * transaction.
+ *
* If the {@code snapshotIndex} is higher than the "correct one", we know that we applied the milestones in the
* wrong order and need to reset the corresponding milestone that wrongly approved this transaction. We therefore
- * add its index to the {@code corruptMilestones} set.
- *
+ * add its index to the {@code corruptMilestones} set.
+ *
* If the milestone does not have the new value set already we add it to the set of {@code transactionsToUpdate} so
- * it can be updated by the caller accordingly.
+ * it can be updated by the caller accordingly.
+ *
+ * This method patches the solid entry points if a back-referencing transaction is detected. + *
+ *
* While we iterate through the approvees of a milestone we stop as soon as we arrive at a transaction that has a
* smaller {@code snapshotIndex} than the milestone. If this {@code snapshotIndex} is also smaller than the index of
- * the milestone of our local snapshot, we have detected a back-referencing transaction.
+ * the milestone of our local snapshot, we have detected a back-referencing transaction.
+ *
* This method is a utility method that checks if the transactions belonging to the potential milestone bundle have
- * a valid structure (used during the validation of milestones).
- *
+ * a valid structure (used during the validation of milestones).
+ *
* It first checks if the bundle has enough transactions to conform to the given {@code securityLevel} and then
* verifies that the {@code branchTransactionsHash}es are pointing to the {@code trunkTransactionHash} of the head
- * transactions.
+ * transactions.
+ *
* This method does the same as {@link #resetCorruptedMilestone(int)} but additionally receives a set of {@code
* processedTransactions} that will allow us to not process the same transactions over and over again while
- * resetting additional milestones in recursive calls.
- *
+ * resetting additional milestones in recursive calls.
+ *
* It first checks if the desired {@code milestoneIndex} is reachable by this node and then triggers the reset
- * by:
- *
- * 1. resetting the ledger state if it addresses a milestone before the current latest solid milestone
- * 2. resetting the {@code milestoneIndex} of all transactions that were confirmed by the current milestone
- * 3. deleting the corresponding {@link StateDiff} entry from the database
- *
+ * by:
+ *
+ * This class implements the basic contract of the {@link MilestoneSolidifier} interface. + *
+ *
* It manages a map of unsolid milestones to collect all milestones that have to be solidified. It then periodically
- * issues checkSolidity calls on the earliest milestones to solidify them.
- *
+ * issues checkSolidity calls on the earliest milestones to solidify them.
+ *
* To save resources and make the call a little bit more efficient, we cache the earliest milestones in a separate map,
* so the relatively expensive task of having to search for the next earliest milestone in the pool only has to be
- * performed after a milestone has become solid or irrelevant for our node.
+ * performed after a milestone has become solid or irrelevant for our node.
+ *
* Defines the maximum amount of transactions that are allowed to get processed while trying to solidify a
- * milestone.
- *
+ * milestone.
+ *
* Note: We want to find the next previous milestone and not get stuck somewhere at the end of the tangle with a
- * long running {@link TransactionValidator#checkSolidity(Hash, boolean)} call.
+ * long running {@link TransactionValidator#checkSolidity(Hash, boolean)} call.
+ *
+ * Holds the milestones that were newly added, but not examined yet. + *
+ *
* Note: This is used to be able to add milestones to the solidifier without having to synchronize the access to the
- * underlying Maps.
+ * underlying Maps.
+ *
+ * Holds and entry that represents the youngest milestone in the {@link #milestonesToSolidify} Map. + *
+ *
* Note: It is used to check if new milestones that are being added, are older that the currently processed ones and
- * should replace them in the queue (we solidify from oldest to youngest).
+ * should replace them in the queue (we solidify from oldest to youngest).
+ *
+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* Since this method might be called from a performance critical context, we simply add the milestone to a temporary
* pool, that gets examined later by the background process. This doesn't just speed up the addition of new jobs but
- * also prevents us from having to synchronize the access to the underlying maps.
+ * also prevents us from having to synchronize the access to the underlying maps.
+ *
* This method takes an entry from the {@link #unsolidMilestonesPool} and adds it to the
- * {@link #milestonesToSolidify} queue.
- *
+ * {@link #milestonesToSolidify} queue.
+ *
* It first checks if the given milestone is already part of the queue and then tries to add it. If the queue is not
* full yet, the addition to the queue is relatively cheap, because the {@link #youngestMilestoneInQueue} marker can
* be updated without iterating over all entries. If the queue reached its capacity already, we replace the entry
* marked by the {@link #youngestMilestoneInQueue} marker and update the marker by recalculating it using
- * {@link #determineYoungestMilestoneInQueue()}.
+ * {@link #determineYoungestMilestoneInQueue()}.
+ *
* This method contains the logic for the milestone solidification, that gets executed in a separate
- * {@link Thread}.
- *
- * It simply executes the necessary steps periodically while waiting a short time to give the nodes the ability to
- * answer to the issued transaction requests.
+ * {@link Thread}.
+ *
+ * It executes the necessary steps periodically while waiting a short time to give the nodes the ability to + * answer to the issued transaction requests. + *
*/ private void milestoneSolidificationThread() { processNewlyAddedMilestones(); @@ -185,13 +209,17 @@ private void milestoneSolidificationThread() { } /** - * This method processes the newly added milestones.+ * This method processes the newly added milestones. + *
+ *
* We process them lazy to decrease the synchronization requirements and speed up the addition of milestones from
- * outside {@link Thread}s.
- *
- * It simply iterates over the milestones and adds them to the pool. If they are older than the
- * {@link #youngestMilestoneInQueue}, we add the to the solidification queue.
+ * outside {@link Thread}s.
+ *
+ * It iterates over the milestones and adds them to the pool. If they are older than the + * {@link #youngestMilestoneInQueue}, we add the to the solidification queue. + *
*/ private void processNewlyAddedMilestones() { for (Iterator+ * This method contains the logic for processing the {@link #milestonesToSolidify}. + *
+ *
* It iterates through the queue and checks if the corresponding milestones are still relevant for our node, or if
* they could be successfully solidified. If the milestones become solid or irrelevant, we remove them from the
- * pool and the queue and reset the {@link #youngestMilestoneInQueue} marker (if necessary).
+ * pool and the queue and reset the {@link #youngestMilestoneInQueue} marker (if necessary).
+ *
* This method takes care of adding new milestones from the pool to the solidification queue, and filling it up
- * again after it was processed / emptied before.
- *
+ * again after it was processed / emptied before.
+ *
* It first updates the {@link #youngestMilestoneInQueue} marker and then just adds new milestones as long as there
- * is still space in the {@link #milestonesToSolidify} queue.
+ * is still space in the {@link #milestonesToSolidify} queue.
+ *
+ * This method determines the youngest milestone in the solidification queue. + *
+ *
* It iterates over all milestones in the Queue and keeps track of the youngest one found (the one with the highest
- * milestone index).
+ * milestone index).
+ *
* This method returns the earliest seen Milestone from the unsolid milestones pool, that is not part of the
- * {@link #milestonesToSolidify} queue yet.
- *
+ * {@link #milestonesToSolidify} queue yet.
+ *
* It simply iterates over all milestones in the pool and looks for the one with the lowest index, that is not
- * getting actively solidified, yet.
+ * getting actively solidified, yet.
+ *
+ * This method performs the actual solidity check on the selected milestone. + *
+ *
* It first dumps a log message to keep the node operator informed about the progress of solidification, and then
* issues the {@link TransactionValidator#checkSolidity(Hash, boolean, int)} call that starts the solidification
- * process.
- *
+ * process.
+ *
* We limit the amount of transactions that may be processed during the solidity check, since we want to solidify
* from the oldest milestone to the newest one and not "block" the solidification with a very recent milestone that
* needs to traverse huge chunks of the tangle. The main goal of this is to give the solidification just enough
- * "resources" to discover the previous milestone while at the same time allowing fast solidity checks.
+ * "resources" to discover the previous milestone while at the same time allowing fast solidity checks.
+ *
+ * Creates a manager that proactively requests the missing "seen milestones" (defined in the local snapshot file). + *
+ *+ * It stores the passed in dependencies in their corresponding properties and then makes a copy of the {@code + * seenMilestones} of the initial snapshot which will consequently be requested. + *
+ *
* Once the manager finishes to request all "seen milestones" it will automatically {@link #shutdown()} (when being
- * {@link #start()}ed before).
+ * {@link #start()}ed before).
+ *
+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties and creates a working copy of the + * seen milestones (which will get processed by the background worker). + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* It simply iterates over the set of seenMilestones and requests them if they are in the range of
* [genesisMilestone ... latestSolidMilestone + RETRIEVE_RANGE]. Milestones that are older than this range get
* deleted because they are irrelevant for the ledger state and milestones that are younger than this range get
- * ignored to be processed later.
- *
+ * ignored to be processed later.
+ *
* This gives the node enough resources to solidify the next milestones without getting its requests queue filled
- * with milestone requests that will become relevant only much later (this achieves a linear sync speed).
- *
- * Note: If no more seen milestones have to be requested, this manager shuts down automatically.
+ * with milestone requests that will become relevant only much later (this achieves a linear sync speed).
+ *
+ * Note: If no more seen milestones have to be requested, this manager shuts down automatically. + *
*/ @Override public void retrieveSeenMilestones() { diff --git a/src/main/java/com/iota/iri/service/restserver/ApiProcessor.java b/src/main/java/com/iota/iri/service/restserver/ApiProcessor.java new file mode 100644 index 0000000000..2a7131f475 --- /dev/null +++ b/src/main/java/com/iota/iri/service/restserver/ApiProcessor.java @@ -0,0 +1,23 @@ +package com.iota.iri.service.restserver; + +import java.net.InetAddress; + +import com.iota.iri.service.dto.AbstractResponse; + +/** + * + * Interface that defines the API call handling + * + */ +@FunctionalInterface +public interface ApiProcessor { + + /** + * Processes the request according to the + * + * @param request the request body, unprocessed + * @param inetAddress the address from the API caller + * @return The response for this request + */ + AbstractResponse processFunction(String request, InetAddress inetAddress); +} diff --git a/src/main/java/com/iota/iri/service/restserver/RestConnector.java b/src/main/java/com/iota/iri/service/restserver/RestConnector.java new file mode 100644 index 0000000000..815b6e10e6 --- /dev/null +++ b/src/main/java/com/iota/iri/service/restserver/RestConnector.java @@ -0,0 +1,27 @@ +package com.iota.iri.service.restserver; + +/** + * + * Connector interface which contains logic for starting and stopping a REST server + * + */ +public interface RestConnector { + + /** + * Initializes the REST server. + * + * @param processFunction the function/class we call after dependency specific handling + */ + void init(ApiProcessor processFunction); + + /** + * Starts the server. + * If {@link #init(ApiProcessor)} has not been called, nothing happens + */ + void start(); + + /** + * Stops the REST server, so no more API calls can be made + */ + void stop(); +} diff --git a/src/main/java/com/iota/iri/service/restserver/resteasy/RestEasy.java b/src/main/java/com/iota/iri/service/restserver/resteasy/RestEasy.java new file mode 100644 index 0000000000..e1b30e67e1 --- /dev/null +++ b/src/main/java/com/iota/iri/service/restserver/resteasy/RestEasy.java @@ -0,0 +1,315 @@ +package com.iota.iri.service.restserver.resteasy; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.ws.rs.ApplicationPath; +import javax.ws.rs.core.Application; +import org.jboss.resteasy.plugins.server.undertow.UndertowJaxrsServer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.xnio.channels.StreamSinkChannel; +import org.xnio.streams.ChannelInputStream; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.iota.iri.Iota; +import com.iota.iri.conf.APIConfig; +import com.iota.iri.service.dto.AbstractResponse; +import com.iota.iri.service.dto.AccessLimitedResponse; +import com.iota.iri.service.dto.ErrorResponse; +import com.iota.iri.service.dto.ExceptionResponse; +import com.iota.iri.service.restserver.ApiProcessor; +import com.iota.iri.service.restserver.RestConnector; +import com.iota.iri.utils.IotaIOUtils; +import com.iota.iri.utils.MapIdentityManager; + +import io.undertow.Handlers; +import io.undertow.Undertow; +import io.undertow.security.api.AuthenticationMechanism; +import io.undertow.security.api.AuthenticationMode; +import io.undertow.security.handlers.AuthenticationCallHandler; +import io.undertow.security.handlers.AuthenticationConstraintHandler; +import io.undertow.security.handlers.AuthenticationMechanismsHandler; +import io.undertow.security.handlers.SecurityInitialHandler; +import io.undertow.security.idm.IdentityManager; +import io.undertow.security.impl.BasicAuthenticationMechanism; +import io.undertow.server.HandlerWrapper; +import io.undertow.server.HttpHandler; +import io.undertow.server.HttpServerExchange; +import io.undertow.servlet.api.DeploymentInfo; +import io.undertow.util.HeaderMap; +import io.undertow.util.Headers; +import io.undertow.util.HttpString; +import io.undertow.util.Methods; +import io.undertow.util.MimeMappings; +import io.undertow.util.StatusCodes; + +/** + * + * Rest connector based on RestEasy, which uses Jaxrs server under the hood. + * This will not actually have any REST endpoints, but rather handle all incoming connections from one point. + * + */ +@ApplicationPath("") +public class RestEasy extends Application implements RestConnector { + + private static final Logger log = LoggerFactory.getLogger(RestEasy.class); + + private final Gson gson = new GsonBuilder().create(); + + private UndertowJaxrsServer server; + + private DeploymentInfo info; + + private ApiProcessor processFunction; + + private int maxBodyLength; + + private String remoteAuth; + + private String apiHost; + + private int port; + + /** + * Required for every {@link Application} + * Will be instantiated once and is supposed to provide REST api classes + * Do not call manually + * + * We handle all calls manually without ever using the {@link Application} functionality using a + * {@link DeploymentInfo#addInnerHandlerChainWrapper} + */ + public RestEasy() { + + } + + /** + * + * @param configuration + */ + public RestEasy(APIConfig configuration) { + maxBodyLength = configuration.getMaxBodyLength(); + port = configuration.getPort(); + apiHost = configuration.getApiHost(); + + remoteAuth = configuration.getRemoteAuth(); + } + + /** + * Prepares the IOTA API for usage. Until this method is called, no HTTP requests can be made. + * The order of loading is as follows + *+ * Processes an API HTTP request. + * No checks have been done until now, except that it is not an OPTIONS request. + * We can be sure that we are in a thread that allows blocking. + *
+ *+ * The request process duration is recorded. + * During this the request gets verified. If it is incorrect, an {@link ErrorResponse} is made. + * Otherwise it is processed in {@link #process(String, InetSocketAddress)}. + * The result is sent back to the requester. + *
+ * + * @param exchange Contains the data the client sent to us + * @throws IOException If the body of this HTTP request cannot be read + */ + private void processRequest(final HttpServerExchange exchange) throws IOException { + final ChannelInputStream cis = new ChannelInputStream(exchange.getRequestChannel()); + exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, "application/json"); + + final long beginningTime = System.currentTimeMillis(); + final String body = IotaIOUtils.toString(cis, StandardCharsets.UTF_8); + AbstractResponse response; + + if (!exchange.getRequestHeaders().contains("X-IOTA-API-Version")) { + response = ErrorResponse.create("Invalid API Version"); + } else if (body.length() > maxBodyLength) { + response = ErrorResponse.create("Request too long"); + } else { + response = this.processFunction.processFunction(body, exchange.getSourceAddress().getAddress()); + } + + sendResponse(exchange, response, beginningTime); + } + + /** + * Updates the {@link HttpServerExchange} {@link HeaderMap} with the proper response settings. + * @param exchange Contains information about what the client has send to us + */ + private static void setupResponseHeaders(HttpServerExchange exchange) { + final HeaderMap headerMap = exchange.getResponseHeaders(); + headerMap.add(new HttpString("Access-Control-Allow-Origin"),"*"); + headerMap.add(new HttpString("Keep-Alive"), "timeout=500, max=100"); + } +} diff --git a/src/main/java/com/iota/iri/service/snapshot/Snapshot.java b/src/main/java/com/iota/iri/service/snapshot/Snapshot.java index 9972117f54..d76754dbcf 100644 --- a/src/main/java/com/iota/iri/service/snapshot/Snapshot.java +++ b/src/main/java/com/iota/iri/service/snapshot/Snapshot.java @@ -1,15 +1,19 @@ package com.iota.iri.service.snapshot; /** + ** Represents a complete Snapshot of the ledger state. - * + *
+ ** The Snapshot is a container for the {@link SnapshotMetaData} and the {@link SnapshotState} and therefore fulfills * both of these contracts while offering some additional utility methods to manipulate them. - * + *
+ ** Important: Since we are only dealing with Snapshots outside of the snapshot package (the underlying meta data and * state objects are not exposed via getters) this class takes care of making the exposed methods thread * safe. The logic of the underlying objects is not thread-safe (for performance and simplicity reasons) but * we don't need to worry about this since we do not have access to them. + *
*/ public interface Snapshot extends SnapshotMetaData, SnapshotState { /** @@ -43,8 +47,10 @@ public interface Snapshot extends SnapshotMetaData, SnapshotState { /** * This methods allows us to keep track when we skip a milestone when applying changes. * + ** Since we can only rollback changes if we know which milestones have lead to the current state, we need to keep * track of the milestones that were previously skipped. + *
* * @param skippedMilestoneIndex index of the milestone that was skipped while applying the ledger state * @return true if the index was added and false if it was already part of the set @@ -54,8 +60,10 @@ public interface Snapshot extends SnapshotMetaData, SnapshotState { /** * This methods allows us to remove a milestone index from the internal list of skipped milestone indexes. * + ** Since we can only rollback changes if we know which milestones have lead to the current state, we need to keep * track of the milestones that were previously skipped. + *
* * @param skippedMilestoneIndex index of the milestone that was skipped while applying the ledger state * @return true if the skipped milestone was removed from the internal list and false if it was not present @@ -65,19 +73,24 @@ public interface Snapshot extends SnapshotMetaData, SnapshotState { /** * Replaces the values of this instance with the values of another snapshot object. * + ** This can for example be used to "reset" the snapshot after a failed modification attempt (while being able to * keep the same instance). + *
* * @param snapshot the new snapshot details that shall overwrite the current ones */ void update(Snapshot snapshot); /** + *
* Creates a deep clone of the Snapshot which can be modified without affecting the values of the original
- * one.
- *
+ * one.
+ *
* Since the data structures inside the Snapshot are extremely big, this method is relatively expensive and should
- * only be used when it is really necessary.
+ * only be used when it is really necessary.
+ *
* Represents the service for snapshots that contains the relevant business logic for modifying {@link Snapshot}s and * generating new local {@link Snapshot}s. - * + *
* This class is stateless and does not hold any domain specific models. */ public interface SnapshotService { /** - * This method applies the balance changes that are introduced by future milestones to the current Snapshot.
* It iterates over the milestone indexes starting from the current index to the target index and applies all found
* milestone balances. If it can not find a milestone for a certain index it keeps track of these skipped
* milestones, which allows us to revert the changes even if the missing milestone was received and processed in the
* mean time. If the application of changes fails, we restore the state of the snapshot to the one it had before the
- * application attempt so this method only modifies the Snapshot if it succeeds.
- *
- * Note: the changes done by this method can be reverted by using {@link #rollBackMilestones(Snapshot, int)}
- *
+ * application attempt so this method only modifies the Snapshot if it succeeds.
+ *
+ * Note: the changes done by this method can be reverted by using {@link #rollBackMilestones(Snapshot, int)}. + *
+ * * @param snapshot the Snapshot that shall get modified * @param targetMilestoneIndex the index of the milestone that should be applied * @throws SnapshotException if something goes wrong while applying the changes @@ -34,16 +37,19 @@ public interface SnapshotService { void replayMilestones(Snapshot snapshot, int targetMilestoneIndex) throws SnapshotException; /** + ** This method rolls back the latest milestones until it reaches the state that the snapshot had before applying * the milestone indicated by the given parameter. - * + *
+ ** When rolling back the milestones we take previously skipped milestones into account, so this method should give * the correct result, even if the missing milestones were received and processed in the mean time. If the rollback * fails, we restore the state of the snapshot to the one it had before the rollback attempt so this method only * modifies the Snapshot if it succeeds. - * + *
+ ** Note: this method is used to reverse the changes introduced by {@link #replayMilestones(Snapshot, int)} - * + *
* @param snapshot the Snapshot that shall get modified * @param targetMilestoneIndex the index of the milestone that should be rolled back (including all following * milestones that were applied) @@ -52,15 +58,19 @@ public interface SnapshotService { void rollBackMilestones(Snapshot snapshot, int targetMilestoneIndex) throws SnapshotException; /** + ** This method takes a "full" local snapshot according to the configuration of the node. - * + *
+ ** It first determines the necessary configuration parameters and which milestone to us as a reference. It then * generates the local {@link Snapshot}, issues the the required {@link TransactionPruner} jobs and writes the * resulting {@link Snapshot} to the disk. - * + *
+ ** After persisting the local snapshot on the hard disk of the node, it updates the {@link Snapshot} instances used * by the {@code snapshotProvider} to reflect the newly created {@link Snapshot}. - * + *
+ * * @param latestMilestoneTracker milestone tracker that allows us to retrieve information about the known milestones * @param transactionPruner manager for the pruning jobs that takes care of cleaning up the old data that * @throws SnapshotException if anything goes wrong while creating the local snapshot @@ -69,12 +79,15 @@ void takeLocalSnapshot(LatestMilestoneTracker latestMilestoneTracker, Transactio SnapshotException; /** + ** This method generates a local snapshot of the full ledger state at the given milestone. - * + *
+ ** The generated {@link Snapshot} contains the balances and meta data plus the derived values like the solid entry * points and all seen milestones, that were issued after the snapshot and can therefore be used to generate the * local snapshot files. - * + *
+ * * @param latestMilestoneTracker milestone tracker that allows us to retrieve information about the known milestones * @param targetMilestone milestone that is used as a reference point for the snapshot * @return a local snapshot of the full ledger state at the given milestone @@ -84,12 +97,15 @@ Snapshot generateSnapshot(LatestMilestoneTracker latestMilestoneTracker, Milesto SnapshotException; /** + ** This method generates the solid entry points for a snapshot that belong to the given milestone. - * + *
+ ** A solid entry point is a confirmed transaction that had non-orphaned approvers during the time of the snapshot * creation and therefore a connection to the most recent part of the tangle. The solid entry points allow us to * stop the solidification process without having to go all the way back to the genesis. - * + *
+ * * @param targetMilestone milestone that is used as a reference point for the snapshot * @return a map of solid entry points associating their hash to the milestone index that confirmed them * @throws SnapshotException if anything goes wrong while generating the solid entry points @@ -97,12 +113,15 @@ Snapshot generateSnapshot(LatestMilestoneTracker latestMilestoneTracker, Milesto Map* This method generates the map of seen milestones that happened after the given target milestone. - * + *
+ ** The map contains the hashes of the milestones associated to their milestone index and is used to allow nodes * that use local snapshot files to bootstrap their nodes, to faster request the missing milestones when syncing the * very first time. - * + *
+ * * @param latestMilestoneTracker milestone tracker that allows us to retrieve information about the known milestones * @param targetMilestone milestone that is used as a reference point for the snapshot * @return a map of solid entry points associating their hash to the milestone index that confirmed them diff --git a/src/main/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImpl.java b/src/main/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImpl.java index d55cfdcc1a..f6562d1617 100644 --- a/src/main/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImpl.java +++ b/src/main/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImpl.java @@ -1,5 +1,6 @@ package com.iota.iri.service.snapshot.impl; +import com.google.common.annotations.VisibleForTesting; import com.iota.iri.conf.SnapshotConfig; import com.iota.iri.service.milestone.LatestMilestoneTracker; import com.iota.iri.service.snapshot.LocalSnapshotManager; @@ -14,11 +15,14 @@ import org.slf4j.LoggerFactory; /** + *
* Creates a manager for the local snapshots, that takes care of automatically creating local snapshots when the defined
- * intervals have passed.
- *
+ * intervals have passed.
+ *
* It incorporates a background worker that periodically checks if a new snapshot is due (see {@link
- * #start(LatestMilestoneTracker)} and {@link #shutdown()}).
+ * #start(LatestMilestoneTracker)} and {@link #shutdown()}).
+ *
+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It simply stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
true if we are in sync, otherwise false
*/
- private boolean isInSync(LatestMilestoneTracker latestMilestoneTracker) {
+ @VisibleForTesting
+ boolean isInSync(LatestMilestoneTracker latestMilestoneTracker) {
if (!latestMilestoneTracker.isInitialScanComplete()) {
return false;
}
-
+
int latestIndex = latestMilestoneTracker.getLatestMilestoneIndex();
int latestSnapshot = snapshotProvider.getLatestSnapshot().getIndex();
-
+
// If we are out of sync, only a full sync will get us in
if (!isInSync && latestIndex == latestSnapshot) {
isInSync = true;
-
- // When we are in sync, only dropping below the buffer gets us out of sync
+
+ // When we are in sync, only dropping below the buffer gets us out of sync
} else if (latestSnapshot < latestIndex - LOCAL_SNAPSHOT_SYNC_BUFFER) {
isInSync = false;
}
-
+
return isInSync;
}
}
diff --git a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImpl.java b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImpl.java
index 9114f8333b..b4a63881be 100644
--- a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImpl.java
+++ b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImpl.java
@@ -1,12 +1,12 @@
package com.iota.iri.service.snapshot.impl;
+import com.google.common.annotations.VisibleForTesting;
import com.iota.iri.SignedFiles;
import com.iota.iri.conf.SnapshotConfig;
import com.iota.iri.model.Hash;
import com.iota.iri.model.HashFactory;
import com.iota.iri.service.snapshot.*;
import com.iota.iri.service.spentaddresses.SpentAddressesException;
-import com.iota.iri.service.spentaddresses.SpentAddressesProvider;
import java.io.*;
import java.nio.file.Files;
@@ -20,9 +20,11 @@
import org.slf4j.LoggerFactory;
/**
- * Creates a data provider for the two {@link Snapshot} instances that are relevant for the node.+ * Creates a data provider for the two {@link Snapshot} instances that are relevant for the node. + *
+ *+ * It provides access to the two relevant {@link Snapshot} instances: *
* Holds a cached version of the builtin snapshot. - * + *
* Note: The builtin snapshot is embedded in the iri.jar and will not change. To speed up tests that need the * snapshot multiple times while creating their own version of the LocalSnapshotManager, we cache the instance * here so they don't have to rebuild it from the scratch every time (massively speeds up the unit tests). */ - private static SnapshotImpl builtinSnapshot = null; + @VisibleForTesting + static SnapshotImpl builtinSnapshot = null; /** * Holds Snapshot related configuration parameters. @@ -80,15 +85,18 @@ public class SnapshotProviderImpl implements SnapshotProvider { private Snapshot latestSnapshot; /** - * This method initializes the instance and registers its dependencies.+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It simply stores the passed in values in their corresponding private properties and loads the snapshots. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* It first writes two temporary files, then renames the current files by appending them with a ".bkp" extension and
* finally renames the temporary files. This mechanism reduces the chances of the files getting corrupted if IRI
* crashes during the snapshot creation and always leaves the node operator with a set of backup files that can be
- * renamed to resume node operation prior to the failed snapshot.
- *
+ * renamed to resume node operation prior to the failed snapshot.
+ *
* Note: We create the temporary files in the same folder as the "real" files to allow the operating system to
- * perform a "rename" instead of a "copy" operation.
+ * perform a "rename" instead of a "copy" operation.
+ *
* Loads the snapshots that are provided by this data provider. - * + *
+ ** We first check if a valid local {@link Snapshot} exists by trying to load it. If we fail to load the local * {@link Snapshot}, we fall back to the builtin one. - * + *
+ ** After the {@link #initialSnapshot} was successfully loaded we create a copy of it that will act as the "working * copy" that will keep track of the latest changes that get applied while the node operates and processes the new * confirmed transactions. - * + *
* @throws SnapshotException if anything goes wrong while loading the snapshots */ private void loadSnapshots() throws SnapshotException, SpentAddressesException { @@ -193,11 +207,14 @@ private void loadSnapshots() throws SnapshotException, SpentAddressesException { } /** + ** Loads the last local snapshot from the disk. - * + *
+ ** This method checks if local snapshot files are available on the hard disk of the node and tries to load them. If * no local snapshot files exist or local snapshots are not enabled we simply return null. - * + *
+ * * @return local snapshot of the node * @throws SnapshotException if local snapshot files exist but are malformed */ @@ -247,14 +264,17 @@ private void assertSpentAddressesDbExist() throws SpentAddressesException { } /** + ** Loads the builtin snapshot (last global snapshot) that is embedded in the jar (if a different path is provided it * can also load from the disk). - * + *
+ ** We first verify the integrity of the snapshot files by checking the signature of the files and then construct * a {@link Snapshot} from the retrieved information. - * + *
+ ** We add the NULL_HASH as the only solid entry point and an empty list of seen milestones. - * + *
* @return the builtin snapshot (last global snapshot) that is embedded in the jar * @throws SnapshotException if anything goes wrong while loading the builtin {@link Snapshot} */ @@ -310,11 +330,14 @@ private Snapshot loadBuiltInSnapshot() throws SnapshotException { //region SNAPSHOT STATE RELATED UTILITY METHODS //////////////////////////////////////////////////////////////////// /** + ** This method reads the balances from the given file on the disk and creates the corresponding SnapshotState. - * - * It simply creates the corresponding reader and for the file on the given location and passes it on to + *
+ *+ * It creates the corresponding reader and for the file on the given location and passes it on to * {@link #readSnapshotState(BufferedReader)}. - * + *
+ * * @param snapshotStateFilePath location of the snapshot state file * @return the unserialized version of the state file * @throws SnapshotException if anything goes wrong while reading the state file @@ -328,10 +351,13 @@ private SnapshotState readSnapshotStatefromFile(String snapshotStateFilePath) th } /** + ** This method reads the balances from the given file in the JAR and creates the corresponding SnapshotState. - * - * It simply creates the corresponding reader and for the file on the given location in the JAR and passes it on to + *
+ *+ * It creates the corresponding reader and for the file on the given location in the JAR and passes it on to * {@link #readSnapshotState(BufferedReader)}. + *
* * @param snapshotStateFilePath location of the snapshot state file * @return the unserialized version of the state file @@ -340,17 +366,20 @@ private SnapshotState readSnapshotStatefromFile(String snapshotStateFilePath) th private SnapshotState readSnapshotStateFromJAR(String snapshotStateFilePath) throws SnapshotException { try (BufferedReader reader = new BufferedReader(new InputStreamReader(new BufferedInputStream(SnapshotProviderImpl.class.getResourceAsStream(snapshotStateFilePath))))) { return readSnapshotState(reader); - } catch (IOException e) { + } catch (NullPointerException | IOException e) { throw new SnapshotException("failed to read the snapshot file from JAR at " + snapshotStateFilePath, e); } } /** + ** This method reads the balances from the given reader. - * + *
+ ** The format of the input is pairs of "address;balance" separated by newlines. It simply reads the input line by * line, adding the corresponding values to the map. - * + *
+ * * @param reader reader allowing us to retrieve the lines of the {@link SnapshotState} file * @return the unserialized version of the snapshot state state file * @throws IOException if something went wrong while trying to access the file @@ -373,10 +402,13 @@ private SnapshotState readSnapshotState(BufferedReader reader) throws IOExceptio } /** + ** This method dumps the current state to a file. - * + *
+ ** It is used by local snapshots to persist the in memory states and allow IRI to resume from the local snapshot. - * + *
+ * * @param snapshotState state object that shall be written * @param snapshotPath location of the file that shall be written * @throws SnapshotException if anything goes wrong while writing the file @@ -402,10 +434,13 @@ private void writeSnapshotStateToDisk(SnapshotState snapshotState, String snapsh //region SNAPSHOT METADATA RELATED UTILITY METHODS ///////////////////////////////////////////////////////////////// /** + ** This method retrieves the metadata of a snapshot from a file. - * + *
+ ** It is used by local snapshots to determine the relevant information about the saved snapshot. - * + *
+ * * @param snapshotMetaDataFile File object with the path to the snapshot metadata file * @return SnapshotMetaData instance holding all the relevant details about the snapshot * @throws SnapshotException if anything goes wrong while reading and parsing the file @@ -608,11 +643,13 @@ private Map* This method writes a file containing a serialized version of the metadata object. - * + *
+ ** It can be used to store the current values and read them on a later point in time. It is used by the local * snapshot manager to generate and maintain the snapshot files. - * + *
* @param snapshotMetaData metadata object that shall be written * @param filePath location of the file that shall be written * @throws SnapshotException if anything goes wrong while writing the file diff --git a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotServiceImpl.java b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotServiceImpl.java index 83e077e23a..bd505542d9 100644 --- a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotServiceImpl.java +++ b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotServiceImpl.java @@ -31,9 +31,12 @@ import org.slf4j.LoggerFactory; /** - * Creates a service instance that allows us to access the business logic for {@link Snapshot}s.+ * Creates a service instance that allows us to access the business logic for {@link Snapshot}s. + *
+ *+ * The service instance is stateless and can be shared by multiple other consumers. + *
*/ public class SnapshotServiceImpl implements SnapshotService { /** @@ -42,9 +45,11 @@ public class SnapshotServiceImpl implements SnapshotService { private static final Logger log = LoggerFactory.getLogger(SnapshotServiceImpl.class); /** + *
* Holds a limit for the amount of milestones we go back in time when generating the solid entry points (to speed up
- * the snapshot creation).
- *
+ * the snapshot creation).
+ *
* Note: Since the snapshot creation is a "continuous" process where we build upon the information gathered during
* the creation of previous snapshots, we do not need to analyze all previous milestones but can rely on
* slowly gathering the missing information over time. While this might lead to a situation where the very
@@ -52,31 +57,35 @@ public class SnapshotServiceImpl implements SnapshotService {
* to sync it is still a reasonable trade-off to reduce the load on the nodes. We just assume that anybody who
* wants to share his snapshots with the community as a way to bootstrap new nodes will run his snapshot
* enabled node for a few hours before sharing his files (this is a problem in very rare edge cases when
- * having back-referencing transactions anyway).
+ * having back-referencing transactions anyway).
+ *
* Maximum age in milestones since creation of solid entry points. - * + *
+ ** Since it is possible to artificially keep old solid entry points alive by periodically attaching new transactions * to them, we limit the life time of solid entry points and ignore them whenever they become too old. This is a * measure against a potential attack vector where somebody might try to blow up the meta data of local snapshots. + *
*/ private static final int SOLID_ENTRY_POINT_LIFETIME = 1000; /** - * Holds the tangle object which acts as a database interface.+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* To increase the performance of this operation, we do not apply every single milestone separately but first
* accumulate all the necessary changes and then apply it to the snapshot in a single run. This allows us to
* modify its values without having to create a "copy" of the initial state to possibly roll back the changes if
- * anything unexpected happens (creating a backup of the state requires a lot of memory).
+ * anything unexpected happens (creating a backup of the state requires a lot of memory).
+ *
* This method reverts the changes caused by the last milestone that was applied to this snapshot. - * + *
+ ** It first checks if we didn't arrive at the initial index yet and then reverts the balance changes that were * caused by the last milestone. Then it checks if any milestones were skipped while applying the last milestone and * determines the {@link SnapshotMetaData} that this Snapshot had before and restores it. - * + *
* @param tangle Tangle object which acts as a database interface * @return true if the snapshot was rolled back or false otherwise * @throws SnapshotException if anything goes wrong while accessing the database @@ -390,11 +406,14 @@ private boolean rollbackLastMilestone(Tangle tangle, Snapshot snapshot) throws S } /** + ** This method determines the milestone that shall be used for the local snapshot. - * + *
+ ** It determines the milestone by subtracting the {@link SnapshotConfig#getLocalSnapshotsDepth()} from the latest * solid milestone index and retrieving the next milestone before this point. - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param snapshotProvider data provider for the {@link Snapshot}s that are relevant for the node * @param config important snapshot related configuration parameters @@ -421,15 +440,18 @@ private MilestoneViewModel determineMilestoneForLocalSnapshot(Tangle tangle, Sna } /** + ** This method creates {@link com.iota.iri.service.transactionpruning.TransactionPrunerJob}s for the expired solid * entry points, which removes the unconfirmed subtangles branching off of these transactions. - * + *
+ ** We only clean up these subtangles if the transaction that they are branching off has been cleaned up already by a * {@link MilestonePrunerJob}. If the corresponding milestone has not been processed we leave them in the database * so we give the node a little bit more time to "use" these transaction for references from future milestones. This * is used to correctly reflect the {@link SnapshotConfig#getLocalSnapshotsPruningDelay()}, where we keep old data * prior to a snapshot. - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param oldSolidEntryPoints solid entry points of the current initial {@link Snapshot} * @param newSolidEntryPoints solid entry points of the new initial {@link Snapshot} @@ -456,12 +478,15 @@ private void cleanupExpiredSolidEntryPoints(Tangle tangle, Map* This method creates the {@link com.iota.iri.service.transactionpruning.TransactionPrunerJob}s that are * responsible for removing the old data. - * + *
+ ** It first calculates the range of milestones that shall be deleted and then issues a {@link MilestonePrunerJob} * for this range (if it is not empty). - * + *
+ * * @param config important snapshot related configuration parameters * @param transactionPruner manager for the pruning jobs that takes care of cleaning up the old data that * @param targetMilestone milestone that was used as a reference point for the local snapshot @@ -483,11 +508,14 @@ private void cleanupOldData(SnapshotConfig config, TransactionPruner transaction } /** + ** This method persists the local snapshot on the disk and updates the instances used by the * {@link SnapshotProvider}. - * + *
+ ** It first writes the files to the disk and then updates the two {@link Snapshot}s accordingly. - * + *
+ * * @param snapshotProvider data provider for the {@link Snapshot}s that are relevant for the node * @param newSnapshot Snapshot that shall be persisted * @param config important snapshot related configuration parameters @@ -508,15 +536,19 @@ private void persistLocalSnapshot(SnapshotProvider snapshotProvider, Snapshot ne } /** + ** This method determines if a transaction is orphaned. - * + *
+ ** Since there is no hard definition for when a transaction can be considered to be orphaned, we define orphaned in * relation to a referenceTransaction. If the transaction or any of its direct or indirect approvers saw a * transaction being attached to it, that arrived after our reference transaction, we consider it "not orphaned". - * + *
+ ** Since we currently use milestones as reference transactions that are sufficiently old, this definition in fact is * a relatively safe way to determine if a subtangle "above" a transaction got orphaned. - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param transaction transaction that shall be checked * @param referenceTransaction transaction that acts as a judge to the other transaction @@ -527,18 +559,13 @@ private void persistLocalSnapshot(SnapshotProvider snapshotProvider, Snapshot ne private boolean isOrphaned(Tangle tangle, TransactionViewModel transaction, TransactionViewModel referenceTransaction, Set* This method checks if a transaction is a solid entry point for the targetMilestone. - * + *
+ ** A transaction is considered a solid entry point if it has non-orphaned approvers. - * + *
+ ** To check if the transaction has non-orphaned approvers we first check if any of its approvers got confirmed by a * future milestone, since this is very cheap. If none of them got confirmed by another milestone we do the more * expensive check from {@link #isOrphaned(Tangle, TransactionViewModel, TransactionViewModel, Set)}. - * + *
+ ** Since solid entry points have a limited life time and to prevent potential problems due to temporary errors in * the database, we assume that the checked transaction is a solid entry point if any error occurs while determining * its status. This is a storage <=> reliability trade off, since the only bad effect of having too many solid entry * points) is a bigger snapshot file. - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param transactionHash hash of the transaction that shall be checked * @param targetMilestone milestone that is used as an anchor for our checks @@ -601,11 +633,14 @@ private boolean isSolidEntryPoint(Tangle tangle, Hash transactionHash, Milestone } /** + ** This method analyzes the old solid entry points and determines if they are still not orphaned. - * + *
+ ** It simply iterates through the old solid entry points and checks them one by one. If an old solid entry point * is found to still be relevant it is added to the passed in map. - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param snapshotProvider data provider for the {@link Snapshot}s that are relevant for the node * @param targetMilestone milestone that is used to generate the solid entry points @@ -633,12 +668,15 @@ && isSolidEntryPoint(tangle, hash, targetMilestone)) { } /** + ** This method retrieves the new solid entry points of the snapshot reference given by the target milestone. - * + *
+ ** It iterates over all unprocessed milestones and analyzes their directly and indirectly approved transactions. * Every transaction is checked for being a solid entry point and added to the passed in map (if it was found to be * one). - * + *
+ * * @param tangle Tangle object which acts as a database interface * @param snapshotProvider data provider for the {@link Snapshot}s that are relevant for the node * @param targetMilestone milestone that is used to generate the solid entry points diff --git a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotStateImpl.java b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotStateImpl.java index 800142288c..3a0ba36d1a 100644 --- a/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotStateImpl.java +++ b/src/main/java/com/iota/iri/service/snapshot/impl/SnapshotStateImpl.java @@ -2,18 +2,12 @@ import com.iota.iri.controllers.TransactionViewModel; import com.iota.iri.model.Hash; -import com.iota.iri.model.HashFactory; import com.iota.iri.service.snapshot.SnapshotException; import com.iota.iri.service.snapshot.SnapshotState; import com.iota.iri.service.snapshot.SnapshotStateDiff; -import com.iota.iri.utils.IotaIOUtils; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.*; -import java.nio.file.Files; -import java.nio.file.Paths; import java.util.HashMap; import java.util.Map; import java.util.Objects; @@ -166,8 +160,7 @@ private Map
* Creates a {@link TransactionPruner} that is able to process it's jobs asynchronously in the background and persists
- * its state in a file on the hard disk of the node.
- *
+ * its state in a file on the hard disk of the node.
+ *
* The asynchronous processing of the jobs is done through {@link Thread}s that are started and stopped by invoking the
* corresponding {@link #start()} and {@link #shutdown()} methods. Since some of the builtin jobs require a special
- * logic for the way they are executed, we register the builtin job types here.
+ * logic for the way they are executed, we register the builtin job types here.
+ *
* The interval (in milliseconds) in which the {@link AsyncTransactionPruner} will persist its state. - * + *
* Note: Since the worst thing that could happen when not having a 100% synced state file is to have a few floating * "zombie" transactions in the database, we do not persist the state immediately but in intervals in a * separate {@link Thread} (to save performance - until a db-based version gets introduced). @@ -67,6 +68,11 @@ public class AsyncTransactionPruner implements TransactionPruner { */ private SpentAddressesService spentAddressesService; + /** + * Used to check whether an address is already persisted in the persistence layer. + */ + private SpentAddressesProvider spentAddressesProvider; + /** * Manager for the tips (required for removing pruned transactions from this manager). */ @@ -79,17 +85,19 @@ public class AsyncTransactionPruner implements TransactionPruner { /** * Holds a reference to the {@link ThreadIdentifier} for the cleanup thread. - * + ** Using a {@link ThreadIdentifier} for spawning the thread allows the {@link ThreadUtils} to spawn exactly one * thread for this instance even when we call the {@link #start()} method multiple times. + *
*/ private final ThreadIdentifier cleanupThreadIdentifier = new ThreadIdentifier("Transaction Pruner"); /** * Holds a reference to the {@link ThreadIdentifier} for the state persistence thread. - * + ** Using a {@link ThreadIdentifier} for spawning the thread allows the {@link ThreadUtils} to spawn exactly one * thread for this instance even when we call the {@link #start()} method multiple times. + *
*/ private final ThreadIdentifier persisterThreadIdentifier = new ThreadIdentifier("Transaction Pruner Persister"); @@ -105,15 +113,18 @@ public class AsyncTransactionPruner implements TransactionPruner { private final Map+ * This method initializes the instance and registers its dependencies. + *
+ *+ * It simply stores the passed in values in their corresponding private properties. + *
+ *
* Note: Instead of handing over the dependencies in the constructor, we register them lazy. This allows us to have
* circular dependencies because the instantiation is separated from the dependency injection. To reduce the
* amount of code that is necessary to correctly instantiate this class, we return the instance itself which
- * allows us to still instantiate, initialize and assign in one line - see Example:
- *
+ * allows us to still instantiate, initialize and assign in one line - see Example:
+ *
* It iterates through all available queues and triggers the processing of their jobs. - * + *
+ * * @throws TransactionPruningException if anything goes wrong while processing the cleanup jobs */ @Override @@ -179,9 +196,10 @@ public void processJobs() throws TransactionPruningException { /** + ** This method removes all queued jobs and resets the state of the {@link TransactionPruner}. It can for example be * used to cleanup after tests. - * + *
* It cycles through all registered {@link JobQueue}s and clears them before persisting the state. */ void clear() { @@ -191,11 +209,14 @@ void clear() { } /** + ** This method starts the cleanup and persistence {@link Thread}s that asynchronously process the queued jobs in the * background. - * + *
+ ** Note: This method is thread safe since we use a {@link ThreadIdentifier} to address the {@link Thread}. The * {@link ThreadUtils} take care of only launching exactly one {@link Thread} that is not terminated. + *
*/ public void start() { ThreadUtils.spawnThread(this::processJobsThread, cleanupThreadIdentifier); @@ -242,9 +263,11 @@ private void addJobQueue(Class jobClass, JobQueu /** * This method allows to register a {@link JobParser} for a given job type. * + ** When we serialize the pending jobs to save the current state, we also dump their class names, which allows us to * generically parse their serialized representation using the registered parser function back into the * corresponding job. + *
* * @param jobClass class of the job that the TransactionPruner shall be able to handle * @param jobParser parser function for the serialized version of jobs of the given type diff --git a/src/main/java/com/iota/iri/service/transactionpruning/jobs/AbstractTransactionPrunerJob.java b/src/main/java/com/iota/iri/service/transactionpruning/jobs/AbstractTransactionPrunerJob.java index ebaf0744df..04795c272b 100644 --- a/src/main/java/com/iota/iri/service/transactionpruning/jobs/AbstractTransactionPrunerJob.java +++ b/src/main/java/com/iota/iri/service/transactionpruning/jobs/AbstractTransactionPrunerJob.java @@ -2,6 +2,7 @@ import com.iota.iri.controllers.TipsViewModel; import com.iota.iri.service.snapshot.Snapshot; +import com.iota.iri.service.spentaddresses.SpentAddressesProvider; import com.iota.iri.service.spentaddresses.SpentAddressesService; import com.iota.iri.service.transactionpruning.TransactionPruner; import com.iota.iri.service.transactionpruning.TransactionPrunerJob; @@ -24,10 +25,15 @@ public abstract class AbstractTransactionPrunerJob implements TransactionPrunerJ private TransactionPruner transactionPruner; /** - * Ascertains that pruned transactions are recorded as spent addresses where necessary + * Ascertains that pruned transactions are recorded as spent addresses where necessary. */ protected SpentAddressesService spentAddressesService; + /** + * Ascertains whether transactions are already added to the underlying persistence layer. + */ + protected SpentAddressesProvider spentAddressesProvider; + /** * Holds a reference to the tangle object which acts as a database interface. */ @@ -96,6 +102,11 @@ public void setSpentAddressesService(SpentAddressesService spentAddressesService this.spentAddressesService = spentAddressesService; } + @Override + public void setSpentAddressesProvider(SpentAddressesProvider spentAddressesProvider) { + this.spentAddressesProvider = spentAddressesProvider; + } + /** * {@inheritDoc} */ diff --git a/src/main/java/com/iota/iri/service/transactionpruning/jobs/MilestonePrunerJob.java b/src/main/java/com/iota/iri/service/transactionpruning/jobs/MilestonePrunerJob.java index b182cc37c9..a32c342286 100644 --- a/src/main/java/com/iota/iri/service/transactionpruning/jobs/MilestonePrunerJob.java +++ b/src/main/java/com/iota/iri/service/transactionpruning/jobs/MilestonePrunerJob.java @@ -269,7 +269,7 @@ private void cleanupMilestoneTransactions() throws TransactionPruningException { approvedTransaction -> approvedTransaction.snapshotIndex() >= milestoneViewModel.index(), approvedTransaction -> { if (approvedTransaction.value() < 0 && - !spentAddressesService.wasAddressSpentFrom(approvedTransaction.getAddressHash())) { + !spentAddressesProvider.containsAddress(approvedTransaction.getAddressHash())) { log.warn("Pruned spend transaction " + approvedTransaction.getHash() + " did not have its spent address recorded. Persisting it now"); spentAddressesService diff --git a/src/main/java/com/iota/iri/storage/Tangle.java b/src/main/java/com/iota/iri/storage/Tangle.java index 5e444bb173..b88ab25c0f 100644 --- a/src/main/java/com/iota/iri/storage/Tangle.java +++ b/src/main/java/com/iota/iri/storage/Tangle.java @@ -1,13 +1,21 @@ package com.iota.iri.storage; +import com.iota.iri.model.Hash; import com.iota.iri.model.StateDiff; -import com.iota.iri.model.persistables.*; +import com.iota.iri.model.persistables.Address; +import com.iota.iri.model.persistables.Approvee; +import com.iota.iri.model.persistables.Bundle; +import com.iota.iri.model.persistables.Milestone; +import com.iota.iri.model.persistables.ObsoleteTag; +import com.iota.iri.model.persistables.Tag; +import com.iota.iri.model.persistables.Transaction; import com.iota.iri.utils.Pair; import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; +import com.iota.iri.zmq.MessageQueueProvider; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -33,23 +41,33 @@ public class Tangle { new AbstractMap.SimpleImmutableEntry<>("transaction-metadata", Transaction.class); private final List* This class represents a wrapper for the {@link org.slf4j.Logger} used by IRI that implements a logic to rate limits * the output on the console. - * + *
+ ** Instead of printing all messages immediately and unnecessarily spamming the console, it only prints messages every * few seconds and if the message has changed since the last output. + *
*/ public class IntervalLogger implements Logger { /** @@ -102,7 +105,7 @@ public IntervalLogger(Class clazz, int logInterval) { /** * Creates a {@link Logger} for the given class that prints messages only every {@code logInterval} milliseconds. * - * It simply stores the passed in parameters in its private properties to be able to access them later on. + * It stores the passed in parameters in its private properties to be able to access them later on. * * @param delegate logback logger for issuing the messages * @param logInterval time in milliseconds between log messages @@ -113,11 +116,12 @@ public IntervalLogger(org.slf4j.Logger delegate, int logInterval) { } /** - * This method returns the underlying logback Logger.
* It can be used to issue log entries directly to the underlying logger without interfering with the logic of this
- * class.
- *
+ * class.
+ *
* It checks if the given message is new and then triggers the output. - * + *
+ * * @param message info message that shall get printed */ @Override @@ -147,7 +153,9 @@ public IntervalLogger info(String message) { /** * {@inheritDoc} * + ** It checks if the given message is new and then triggers the output. + *
*/ @Override public IntervalLogger debug(String message) { @@ -165,11 +173,14 @@ public IntervalLogger debug(String message) { /** * {@inheritDoc} * + ** It checks if the given message is new and then triggers the output. - * + *
+ ** Error messages will always get dumped immediately instead of scheduling their output. Since error messages are * usually a sign of some misbehaviour of the node we want to be able to see them when they appear (to be able to * track down bugs more easily). + *
*/ @Override public IntervalLogger error(String message) { @@ -178,12 +189,15 @@ public IntervalLogger error(String message) { /** * {@inheritDoc} - * + * + ** It checks if the given message is new and then triggers the output. - * + *
+ ** Error messages will always get dumped immediately instead of scheduling their output. Since error messages are * usually a sign of some misbehaviour of the node we want to be able to see them when they appear (to be able to * track down bugs more easily). + *
*/ @Override public IntervalLogger error(String message, Throwable cause) { @@ -225,11 +239,14 @@ public void triggerOutput() { } /** + ** Triggers the output of the last received message. - * + *
+ ** It either prints the message immediately (if enough time has passed since the last output or requested by the * caller) or schedules it for the next interval. - * + *
+ * * @param printImmediately flag indicating if the messages should be scheduled or printed immediately */ public void triggerOutput(boolean printImmediately) { @@ -243,11 +260,14 @@ public void triggerOutput(boolean printImmediately) { } /** + ** This method schedules the output of the last received message by spawning a {@link Thread} that will print the * new message after the given timeout. - * + *
+ ** When creating the {@link Thread} it copies its name so the output is "transparent" to the user and the effect * is the same as dumping the message manually through the {@link org.slf4j.Logger} object itself. + *
*/ private void scheduleOutput() { if (outputScheduled.compareAndSet(false, true)) { @@ -273,7 +293,7 @@ private abstract class Message { /** * Creates a message that gets managed by this logger. * - * It simply stores the provided message in the internal property. + * It stores the provided message in the internal property. * * @param message message that shall get printed */ @@ -284,9 +304,11 @@ public Message(String message) { /** * This method triggers the output of the given message. * + ** It first cancels any scheduled job because the latest provided message will be printed by this call already * and then triggers the printing of the message through the instance specific {@link #print()} method. - * + *
+ * * We only print the message if the same method was not printed already, before. */ public void output() { @@ -340,10 +362,11 @@ public boolean equals(Object obj) { /** * This method handles the actual output of messages through the {@link org.slf4j.Logger} instance. - * + ** It first checks if the message that shall get printed differs from the last message that was printed and then * issues the output of the message. After printing the message, it updates the internal variables to handle the * next message accordingly. + *
*/ protected abstract void print(); } diff --git a/src/main/java/com/iota/iri/utils/thread/BoundedScheduledExecutorService.java b/src/main/java/com/iota/iri/utils/thread/BoundedScheduledExecutorService.java index d0b19f4cea..7b81a50dfe 100644 --- a/src/main/java/com/iota/iri/utils/thread/BoundedScheduledExecutorService.java +++ b/src/main/java/com/iota/iri/utils/thread/BoundedScheduledExecutorService.java @@ -8,50 +8,58 @@ import java.util.concurrent.atomic.AtomicInteger; /** + *
* This class represents a {@link SilentScheduledExecutorService} that accepts only a pre-defined amount of tasks that
* can be queued or executed at the same time. All tasks exceeding the defined limit will be ignored (instead of being
* queued) by either throwing a {@link RejectedExecutionException} or returning {@code null} depending on the method we
- * call (non-silent vs silent).
- *
+ * call (non-silent vs silent).
+ *
* Whenever a non-recurring task finishes (or a recurring one is cancelled through its {@link Future}), it makes space
* for a new task. This is useful for classes like the {@link com.iota.iri.utils.log.interval.IntervalLogger} that want
- * to delay an action if and only if there is no other delayed action queued already.
- *
+ * to delay an action if and only if there is no other delayed action queued already.
+ *
* Note: In contrast to other existing implementations like the SizedScheduledExecutorService of the apache package,
* this class is thread-safe and will only allow to spawn and queue the exact amount of tasks defined during its
- * creation (since it does not rely on approximate numbers like the queue size).
+ * creation (since it does not rely on approximate numbers like the queue size).
+ *
+ * Note: Whenever a task finishes, we clean up the used resources and make space for new tasks. + *
*/ private AtomicInteger scheduledTasksCounter = new AtomicInteger(0); /** + *
* Creates an executor service that that accepts only a pre-defined amount of tasks that can be queued and run at
- * the same time.
- *
+ * the same time.
+ *
* All tasks exceeding the defined limit will be ignored (instead of being queued) by either throwing a
* {@link RejectedExecutionException} or returning {@code null} depending on the method we call (non-silent vs
- * silent).
+ * silent).
+ *
+ * It simply adds the task to the internal set of scheduled tasks. + *
*/ @Override public void onScheduleTask(TaskDetails taskDetails) { @@ -90,9 +100,11 @@ public void onCancelTask(TaskDetails taskDetails) { /** * {@inheritDoc} - *
* It frees the reserved resources by decrementing the {@link #scheduledTasksCounter} and removing the task from the
- * {@link #scheduledTasks} set.
+ * {@link #scheduledTasks} set.
+ *
* Note: Since the {@link ScheduledFuture} returned by this method allows to cancel jobs without their unwinding
* logic being executed, we wrap the returned {@link ScheduledFuture} AND the {@link Runnable} to correctly
- * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ *
* Note: Since the {@link ScheduledFuture} returned by this method allows to cancel jobs without their unwinding
* logic being executed, we wrap the returned {@link ScheduledFuture} AND the {@link Callable} to correctly
- * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ *
* Note: Since the {@link ScheduledFuture} returned by this method allows to cancel jobs without their unwinding
* logic being executed, we wrap the returned {@link ScheduledFuture} AND the {@link Runnable} to correctly
- * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ *
* Note: Since the {@link ScheduledFuture} returned by this method allows to cancel jobs without their unwinding
* logic being executed, we wrap the returned {@link ScheduledFuture} AND the {@link Runnable} to correctly
- * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ * free the resources if its {@link ScheduledFuture#cancel(boolean)} method is called.
+ *
* Note: Since the {@link Future} returned by this method allows to cancel jobs without their unwinding logic being
* executed, we wrap the returned {@link Future} AND the {@link Callable} to correctly free the resources if
- * its {@link Future#cancel(boolean)} method is called.
+ * its {@link Future#cancel(boolean)} method is called.
+ *
* Note: Since the {@link Future} returned by this method allows to cancel jobs without their unwinding logic being
* executed, we wrap the returned {@link Future} AND the {@link Runnable} to correctly free the resources if
- * its {@link Future#cancel(boolean)} method is called.
+ * its {@link Future#cancel(boolean)} method is called.
+ *
* Note: Since the {@link Future} returned by this method allows to cancel jobs without their unwinding logic being
* executed, we wrap the returned {@link Future} AND the {@link Runnable} to correctly free the resources if
- * its {@link Future#cancel(boolean)} method is called.
+ * its {@link Future#cancel(boolean)} method is called.
+ *
* Note: Since the {@link Future}s will all be finished (and cannot be cancelled anymore) when the underlying method
* returns, we only wrap the {@link Callable}s to correctly free the resources and omit wrapping the returned
- * {@link Future}s.
+ * {@link Future}s.
+ *
* Note: Since the {@link Future}s will all be finished (and cannot be cancelled anymore) when the underlying method
* returns, we only wrap the {@link Callable}s to correctly free the resources and omit wrapping the returned
- * {@link Future}s.
+ * {@link Future}s.
+ *
* Note: Since the {@link Future}s are not passed to the caller, we only wrap the {@link Callable}s to correctly
- * free the resources and omit wrapping the {@link Future}s as well.
+ * free the resources and omit wrapping the {@link Future}s as well.
+ *
* Note: Since the {@link Future}s are not passed to the caller, we only wrap the {@link Callable}s to correctly
- * free the resources and omit wrapping the related {@link Future}s as well.
+ * free the resources and omit wrapping the related {@link Future}s as well.
+ *
* Note: Since there is no {@link Future} passed to the caller, we only wrap the {@link Runnable} to correctly free
- * the resources.
+ * the resources.
+ *
* In addition to delegating the method call to the internal {@link ScheduledExecutorService}, we call the cancel
* logic for recurring tasks because shutdown prevents them from firing again. If these "cancelled" jobs are
* scheduled for execution (and not running right now), we also call their
* {@link #onCompleteTask(TaskDetails, Throwable)} callback to "report" that hey have finished (otherwise this will
- * be fired inside the wrapped task).
+ * be fired inside the wrapped task).
+ *
* Before delegating the method call to the internal {@link ScheduledExecutorService}, we call the
* {@link #onCancelTask(TaskDetails)} callback for all scheduled tasks and fire the
* {@link #onCompleteTask(TaskDetails, Throwable)} callback for all tasks that are not being executed right now
- * (otherwise this will be fired inside the wrapped task).
+ * (otherwise this will be fired inside the wrapped task).
+ *
+ * "Original" unwrapped {@link Future} that is returned by the delegated {@link ScheduledExecutorService}. + *
+ *
* Note: All methods except the {@link #cancel(boolean)} are getting passed through without any
- * modifications.
+ * modifications.
+ *
* This creates a {@link WrappedFuture} that cleans up the reserved resources when it is cancelled while the
- * task is still pending.
- *
+ * task is still pending.
+ *
* We do not hand in the {@link #delegate} in the constructor because we need to populate this instance to the
- * wrapped task before we "launch" the processing of the task (see {@link #delegate(Future)}).
+ * wrapped task before we "launch" the processing of the task (see {@link #delegate(Future)}).
+ *
+ * This method stores the delegated {@link Future} in its internal property. + *
+ *
* After the delegated {@link Future} is created, the underlying {@link ScheduledExecutorService} starts
* processing the task. To be able to "address" this wrapped future before we start processing the task (the
* wrapped task needs to access it), we populate this lazy (see
* {@link #wrapFuture(FutureFactory, Runnable, TaskDetails)} and
- * {@link #wrapFuture(FutureFactory, Callable, TaskDetails)}).
+ * {@link #wrapFuture(FutureFactory, Callable, TaskDetails)}).
+ *
+ * This method returns the delegated future. + *
+ *
* We define a getter for this property to be able to override it in the extending class and achieve a
- * polymorphic behavior.
+ * polymorphic behavior.
+ *
* This method fires the {@link #onCancelTask(TaskDetails)} if the future has not been cancelled before.
* Afterwards it also fires the {@link #onCompleteTask(TaskDetails, Throwable)} callback if the task is not
- * running right now (otherwise this will be fired inside the wrapped task).
+ * running right now (otherwise this will be fired inside the wrapped task).
+ *
* "Original" unwrapped {@link ScheduledFuture} that is returned by the delegated
- * {@link ScheduledExecutorService}.
- *
+ * {@link ScheduledExecutorService}.
+ *
* Note: All methods except the {@link #cancel(boolean)} are getting passed through without any modifications. + *
*/ private ScheduledFuture
* This creates a {@link ScheduledFuture} that cleans up the reserved resources when it is cancelled while the
- * task is still pending.
- *
+ * task is still pending.
+ *
* We do not hand in the {@link #delegate} in the constructor because we need to populate this instance to the * wrapped task before we "launch" the processing of the task (see {@link #delegate(Future)}). - * + *
+ * * @param taskDetails metadata holding the relevant information of the task */ private WrappedScheduledFuture(TaskDetails taskDetails) { @@ -606,12 +666,15 @@ private WrappedScheduledFuture(TaskDetails taskDetails) { } /** - * This method stores the delegated {@link ScheduledFuture} in its internal property.+ * This method stores the delegated {@link ScheduledFuture} in its internal property. + *
+ *
* After the delegated {@link ScheduledFuture} is created, the underlying {@link ScheduledExecutorService}
* starts processing the task. To be able to "address" this wrapped future before we start processing the task
* (the wrapped task needs to access it), we populate this lazy (see
- * {@link #wrapScheduledFuture(FutureFactory, Runnable, TaskDetails)}).
+ * {@link #wrapScheduledFuture(FutureFactory, Runnable, TaskDetails)}).
+ *
* This method fires the {@link #onCancelTask(TaskDetails)} if the future has not been cancelled before.
* Afterwards it also fires the {@link #onCompleteTask(TaskDetails, Throwable)} callback if the task is not
- * running right now (otherwise this will be fired inside the wrapped task).
+ * running right now (otherwise this will be fired inside the wrapped task).
+ *
+ * This method wraps the passed in task to automatically call the callbacks for its lifecycle. + *
+ *+ * The lifecycle methods are for example used to manage the resources that are reserved for this task. + *
* * @param task the raw task that shall be wrapped with the resource freeing logic * @param taskDetails metadata holding the relevant information of the task @@ -709,11 +777,14 @@ private
* This method does the same as {@link #wrapTask(Callable, TaskDetails, Future)} but defaults to a task that is not
- * associated to a user accessible {@link Future}.
- *
+ * associated to a user accessible {@link Future}.
+ *
* This method is used whenever the {@link Future} is not returned by the underlying method so we don't need to wrap
- * it.
+ * it.
+ *
+ * This method wraps the passed in task to automatically call the callbacks for its lifecycle. + *
+ *+ * The lifecycle methods are for example used to manage the resources that are reserved for this task. + *
* * @param task the raw task that shall be wrapped with the resource freeing logic * @param taskDetails metadata holding the relevant information of the task @@ -767,11 +841,14 @@ private
* This method does the same as {@link #wrapTask(Runnable, TaskDetails, Future)} but defaults to a task that is not
- * associated to a user accessible {@link Future}.
- *
+ * associated to a user accessible {@link Future}.
+ *
* This method is used whenever the {@link Future} is not returned by the underlying method so we don't need to wrap
- * it.
+ * it.
+ *
+ * This is a utility method that wraps the task and the resulting {@link Future} in a single call. + *
+ *
* It creates the {@link WrappedFuture} and the wrapped task and starts the execution of the task by delegating
- * the launch through the {@link FutureFactory}.
+ * the launch through the {@link FutureFactory}.
+ *
+ * This is a utility method that wraps the task and the resulting {@link Future} in a single call. + *
+ *
* It creates the {@link WrappedFuture} and the wrapped task and starts the execution of the task by delegating
- * the launch through the {@link FutureFactory}.
+ * the launch through the {@link FutureFactory}.
+ *
+ * This is a utility method that wraps the task and the resulting {@link ScheduledFuture} in a single call. + *
+ *
* It creates the {@link WrappedScheduledFuture} and the wrapped task and starts the execution of the task by
- * delegating the launch through the {@link FutureFactory}.
+ * delegating the launch through the {@link FutureFactory}.
+ *
+ * This is a utility method that wraps the task and the resulting {@link ScheduledFuture} in a single call. + *
+ *
* It creates the {@link WrappedScheduledFuture} and the wrapped task and starts the execution of the task by
- * delegating the launch through the {@link FutureFactory}.
+ * delegating the launch through the {@link FutureFactory}.
+ *
* It simply iterates over the tasks and wraps them one by one by calling
- * {@link #wrapTask(Callable, TaskDetails)}.
+ * {@link #wrapTask(Callable, TaskDetails)}.
+ *
* The reserved resources will be freed again once the tasks finish their execution or when they are cancelled
- * through their corresponding {@link Future}.
+ * through their corresponding {@link Future}.
+ *
* This method is a utility method that simply checks the passed in object for being {@code null} and throws a
- * {@link RejectedExecutionException} if it is.
- *
+ * {@link RejectedExecutionException} if it is.
+ *
* It is used to turn the silent methods into non-silent ones and conform with the {@link ScheduledExecutorService}
- * interface.
+ * interface.
+ *
* This class represents a {@link ScheduledExecutorService} that is associated with one specific task for which it
- * provides automatic logging capabilities
- *
+ * provides automatic logging capabilities.
+ *
* It informs the user about its lifecycle using the logback loggers used by IRI. In addition it offers "silent" methods
* of the {@link ScheduledExecutorService} that do not throw {@link Exception}s when we try to start the same task
* multiple times. This is handy for implementing the "start" and "shutdown" methods of the background workers of IRI
* that would otherwise have to take care of not starting the same task more than once (when trying to be robust against
- * coding errors or tests that start the same thread multiple times).
+ * coding errors or tests that start the same thread multiple times).
+ *
* Note: The used logger can be overwritten by providing a different logger in the constructor (to have transparent
- * log messages that look like they are coming from a different source).
+ * log messages that look like they are coming from a different source).
+ *
* Creates a {@link ScheduledExecutorService} that is associated with one specific task for which it provides
- * automatic logging capabilities (using the provided thread name).
- *
+ * automatic logging capabilities (using the provided thread name).
+ *
* It informs the user about its lifecycle using the logback loggers used by IRI. In addition it offers "silent"
* methods of the {@link ScheduledExecutorService} that do not throw {@link Exception}s when we try to start the
* same task multiple times. This is handy for implementing the "start" and "shutdown" methods of the background
* workers of IRI that would otherwise have to take care of not starting the same task more than once (when trying
- * to be robust against coding errors or tests that start the same thread multiple times).
- *
+ * to be robust against coding errors or tests that start the same thread multiple times).
+ *
*
* Example:
*
@@ -82,7 +89,8 @@ public class DedicatedScheduledExecutorService extends BoundedScheduledExecutorS
* [main] INFO MilestoneSolidifier - [Milestone Solidifier] Stopped (after #4 executions) ...
*
- *
+ *
+ *
* @param threadName name of the thread (or null if we want to disable the automatic logging - exceptions will
* always be logged)
* @param logger logback logger that shall be used for the origin of the log messages
@@ -98,7 +106,7 @@ public DedicatedScheduledExecutorService(String threadName, Logger logger, boole
/**
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to the
- * {@link #DEFAULT_LOGGER} for the log messages.
+ * {@link #DEFAULT_LOGGER} for the log messages.
*
* @param threadName name of the thread (or null if we want to disable the automatic logging - exceptions will
* always be logged)
@@ -110,7 +118,7 @@ public DedicatedScheduledExecutorService(String threadName, boolean debug) {
/**
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to false
- * for the debug flag.
+ * for the debug flag.
*
* @param threadName name of the thread (or null if we want to disable the automatic logging - exceptions will
* always be logged)
@@ -121,11 +129,14 @@ public DedicatedScheduledExecutorService(String threadName, Logger logger) {
}
/**
+ *
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to {@code null}
- * for the thread name (which causes only error messages to be printed - unless debug is true).
- *
+ * for the thread name (which causes only error messages to be printed - unless debug is true).
+ *
+ *
* Note: This is for example used by the {@link com.iota.iri.utils.log.interval.IntervalLogger} which does not want
- * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ *
*
* @param logger logback logger that shall be used for the origin of the log messages
* @param debug debug flag that indicates if every "run" should be accompanied with a log message
@@ -136,7 +147,7 @@ public DedicatedScheduledExecutorService(Logger logger, boolean debug) {
/**
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to the
- {@link #DEFAULT_LOGGER} for the log messages and false for the debug flag.
+ {@link #DEFAULT_LOGGER} for the log messages and false for the debug flag.
*
* @param threadName name of the thread (or null if we want to disable the automatic logging - exceptions will
* always be logged)
@@ -146,13 +157,16 @@ public DedicatedScheduledExecutorService(String threadName) {
}
/**
+ *
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to {@code null}
* for the thread name (which causes only error messages to be printed - unless debug is true) and and false for the
- * debug flag.
- *
+ * debug flag.
+ *
+ *
* Note: This is for example used by the {@link com.iota.iri.utils.log.interval.IntervalLogger} which does not want
- * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
- *
+ * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ *
+ *
* @param logger logback logger that shall be used for the origin of the log messages
*/
public DedicatedScheduledExecutorService(Logger logger) {
@@ -160,12 +174,15 @@ public DedicatedScheduledExecutorService(Logger logger) {
}
/**
+ *
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to {@code null}
* for the thread name (which causes only error messages to be printed - unless debug is true) and the
- * {@link #DEFAULT_LOGGER} for the log messages.
- *
+ * {@link #DEFAULT_LOGGER} for the log messages.
+ *
+ *
* Note: This is for example used by the {@link com.iota.iri.utils.log.interval.IntervalLogger} which does not want
- * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ *
*
* @param debug debug flag that indicates if every "run" should be accompanied with a log message
*/
@@ -174,19 +191,22 @@ public DedicatedScheduledExecutorService(boolean debug) {
}
/**
+ *
* Does the same as {@link #DedicatedScheduledExecutorService(String, Logger, boolean)} but defaults to {@code null}
* for the thread name (which causes only error messages to be printed), the {@link #DEFAULT_LOGGER} for the log
- * messages and {@code false} for the debug flag.
- *
+ * messages and {@code false} for the debug flag.
+ *
+ *
* Note: This is for example used by the {@link com.iota.iri.utils.log.interval.IntervalLogger} which does not want
- * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ * to inform the user when scheduling a log output, but which still needs the "only run one task" logic.
+ *
*/
public DedicatedScheduledExecutorService() {
this(null, DEFAULT_LOGGER, false);
}
/**
- * This method is the getter for the name of the thread that gets created by this service.
+ * This method is the getter for the name of the thread that gets created by this service.
*
* @return it simply returns the private property of {@link #threadName}.
*/
@@ -198,10 +218,14 @@ public String getThreadName() {
/**
* {@inheritDoc}
- * This method shows a message whenever a task gets successfully scheduled.
- *
+ *
+ *
+ * This method shows a message whenever a task gets successfully scheduled.
+ *
+ *
* We only show the scheduling message if debugging is enabled or a thread name was defined when creating this
- * {@link DedicatedScheduledExecutorService} (to not pollute the CLI with meaningless messages).
+ * {@link DedicatedScheduledExecutorService} (to not pollute the CLI with meaningless messages).
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -216,17 +240,23 @@ public void onScheduleTask(TaskDetails taskDetails) {
/**
* {@inheritDoc}
- * This method shows a message whenever a task starts to be processed.
- *
+ *
+ *
+ * This method shows a message whenever a task starts to be processed.
+ *
+ *
* We only show the starting message if debug is enabled or if it is the first start of the task in a named
* {@link DedicatedScheduledExecutorService} (display it like it would be a {@link Thread} with one start message
- * and one stop message - to not pollute the CLI with meaningless messages).
- *
+ * and one stop message - to not pollute the CLI with meaningless messages).
+ *
+ *
* To increase the information available for debugging, we change the thread name to the one that initiated the
- * start (rather than the randomly assigned one from the executor service) before printing the start message.
- *
+ * start (rather than the randomly assigned one from the executor service) before printing the start message.
+ *
+ *
* After the start message was printed, we set the name of the {@link Thread} that will consequently be used for log
- * messages from the task itself.
+ * messages from the task itself.
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -249,15 +279,20 @@ public void onStartTask(TaskDetails taskDetails) {
/**
* {@inheritDoc}
+ *
+ *
* This method shows a message when the task finishes its execution (can happen multiple times for recurring
- * tasks).
- *
+ * tasks).
+ *
+ *
* We only show the finishing message if debug is enabled and if no error occurred (otherwise the
- * {@link #onCompleteTask(TaskDetails, Throwable)} callback will give enough information about the crash).
- *
+ * {@link #onCompleteTask(TaskDetails, Throwable)} callback will give enough information about the crash).
+ *
+ *
* To be consistent with the start message, we change the thread name to the one that initiated the task (this also
* makes it easier to distinguish log messages that are emitted by the "real" logic of the task from the "automated"
- * messages about its lifecycle).
+ * messages about its lifecycle).
+ *
*
* @param taskDetails metadata holding the relevant information of the task
* @param error the exception that caused this task to terminate or {@code null} if it terminated normally
@@ -275,10 +310,14 @@ public void onFinishTask(TaskDetails taskDetails, Throwable error) {
/**
* {@inheritDoc}
- * This method shows an information about the intent to cancel the task.
- *
+ *
+ *
+ * This method shows an information about the intent to cancel the task.
+ *
+ *
* We only show the cancel message if debugging is enabled or a thread name was defined when creating this
- * {@link DedicatedScheduledExecutorService} (to not pollute the CLI with meaningless messages).
+ * {@link DedicatedScheduledExecutorService} (to not pollute the CLI with meaningless messages).
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -293,15 +332,21 @@ public void onCancelTask(TaskDetails taskDetails) {
/**
* {@inheritDoc}
+ *
+ *
* This method shows a stopped message whenever it finally terminates (and doesn't get launched again in case of
- * recurring tasks).
- *
+ * recurring tasks).
+ *
+ *
* We only show the stopped message if debug is enabled, an exception occurred (always show unexpected errors) or if
* we have a named {@link DedicatedScheduledExecutorService} (to not pollute the CLI with meaningless
- * messages).
+ * messages).
+ *
+ *
* If the completion of the task was not caused by an outside call to cancel it, we change the thread name to the
* one that initiated the task (this makes it easier to distinguish log messages that are emitted by the "real"
- * logic of the task from the "automated" messages about its lifecycle).
+ * logic of the task from the "automated" messages about its lifecycle).
+ *
*
* @param taskDetails metadata holding the relevant information of the task
* @param error the exception that caused this task to terminate or {@code null} if it terminated normally
@@ -329,10 +374,13 @@ public void onCompleteTask(TaskDetails taskDetails, Throwable error) {
//region PRIVATE UTILITY METHODS ///////////////////////////////////////////////////////////////////////////////////
/**
- * This method is a utility method that prints the schedule message of the task.
- *
+ *
+ * This method is a utility method that prints the schedule message of the task.
+ *
+ *
* It constructs the matching message by passing the task details into the
- * {@link #buildScheduledMessage(TaskDetails)} method.
+ * {@link #buildScheduledMessage(TaskDetails)} method.
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -341,10 +389,13 @@ private void printScheduledMessage(TaskDetails taskDetails) {
}
/**
- * This method is a utility method that prints the started message of the task.
- *
+ *
+ * This method is a utility method that prints the started message of the task.
+ *
+ *
* It constructs the message by passing the details into the {@link #buildStartedMessage(TaskDetails)} and printing
- * it through the logger.
+ * it through the logger.
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -353,10 +404,13 @@ private void printStartedMessage(TaskDetails taskDetails) {
}
/**
- * This method is a utility method that prints the finished message of the task.
- *
+ *
+ * This method is a utility method that prints the finished message of the task.
+ *
+ *
* It constructs the message by passing the details into the {@link #buildFinishedMessage(TaskDetails)} and printing
- * it through the logger.
+ * it through the logger.
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -365,10 +419,13 @@ private void printFinishedMessage(TaskDetails taskDetails) {
}
/**
- * This method is a utility method that prints the stop message of the task.
- *
+ *
+ * This method is a utility method that prints the stop message of the task.
+ *
+ *
* It constructs the message by passing the details into the {@link #buildStopMessage(TaskDetails)} and printing
- * it through the logger.
+ * it through the logger.
+ *
*
* @param taskDetails metadata holding the relevant information of the task
*/
@@ -377,12 +434,15 @@ private void printStopMessage(TaskDetails taskDetails) {
}
/**
- * This method is a utility method that prints the stopped message of the task.
- *
+ *
+ * This method is a utility method that prints the stopped message of the task.
+ *
+ *
* It constructs the message by passing the details into the {@link #buildStoppedMessage(TaskDetails, Throwable)}
* and printing it through the logger. If an error occurred we use the error channel and append the error to
- * get a stack trace of what happened.
- *
+ * get a stack trace of what happened.
+ *
+ *
* @param taskDetails metadata holding the relevant information of the task
* @param error the exception that caused the task to be stopped
*/
@@ -396,10 +456,13 @@ private void printStoppedMessage(TaskDetails taskDetails, Throwable error) {
}
/**
- * This method is a utility method that generates the thread name that is used in the log messages.
- *
+ *
+ * This method is a utility method that generates the thread name that is used in the log messages.
+ *
+ *
* It simply returns the thread name (if one is set) or generates a name if this
- * {@link DedicatedScheduledExecutorService} is "unnamed".
+ * {@link DedicatedScheduledExecutorService} is "unnamed".
+ *
*
* @return the thread name that is used in the log messages
*/
@@ -411,7 +474,7 @@ private String getPrintableThreadName(TaskDetails taskDetails) {
/**
* This method creates the schedule message of the task by first building the temporal parts of the message and
- * then appending them to the actual message.
+ * then appending them to the actual message.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the schedule message that can be used with the logger
@@ -435,7 +498,7 @@ private String buildScheduledMessage(TaskDetails taskDetails) {
/**
* This method creates the started message of the task by simply extracting the relevant information from the
- * {@code taskDetails} and concatenating them to the actual message.
+ * {@code taskDetails} and concatenating them to the actual message.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the started message that can be used with the logger
@@ -449,7 +512,7 @@ private String buildStartedMessage(TaskDetails taskDetails) {
/**
* This method creates the finished message of the task by simply extracting the relevant information from the
- * {@code taskDetails} and concatenating them to the actual message.
+ * {@code taskDetails} and concatenating them to the actual message.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the finished message that can be used with the logger
@@ -463,7 +526,7 @@ private String buildFinishedMessage(TaskDetails taskDetails) {
/**
* This method creates the stop message of the task by simply extracting the relevant information from the
- * {@code taskDetails} and concatenating them to the actual message.
+ * {@code taskDetails} and concatenating them to the actual message.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the stop message that can be used with the logger
@@ -475,12 +538,15 @@ private String buildStopMessage(TaskDetails taskDetails) {
: "Cancelling Start [" + printableThreadName + "] ...";
}
- /**
+ /**
+ *
* This method creates the stopped message of the task by simply extracting the relevant information from the
- * {@code taskDetails} and concatenating them to the actual message.
- *
- * We differentiate between different termination ways by giving different reasons in the message.
- *
+ * {@code taskDetails} and concatenating them to the actual message.
+ *
+ *
+ * We differentiate between different termination ways by giving different reasons in the message.
+ *
+ *
* @param taskDetails metadata holding the relevant information of the task
* @return the stop message that can be used with the logger
*/
@@ -500,7 +566,7 @@ private String buildStoppedMessage(TaskDetails taskDetails, Throwable error) {
/**
* This method is a utility method that builds the message fragment which expresses the delay of the scheduled
- * task.
+ * task.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the message fragment which expresses the delay of the scheduled task
@@ -515,7 +581,7 @@ private String buildDelayMessageFragment(TaskDetails taskDetails) {
/**
* This method is a utility method that builds the message fragment which expresses the interval of the scheduled
- * task.
+ * task.
*
* @param taskDetails metadata holding the relevant information of the task
* @return the message fragment which expresses the interval of the scheduled task
@@ -530,7 +596,7 @@ private String buildIntervalMessageFragment(TaskDetails taskDetails) {
/**
* This method is a utility method that creates a human readable abbreviation of the provided
- * {@link TimeUnit}.
+ * {@link TimeUnit}.
*
* @param unit the time unit used for the values in the {@link TaskDetails}
* @return a human readable abbreviation of the provided {@link TimeUnit}
diff --git a/src/main/java/com/iota/iri/utils/thread/ReportingExecutorService.java b/src/main/java/com/iota/iri/utils/thread/ReportingExecutorService.java
index d10c3a71fc..96160efb78 100644
--- a/src/main/java/com/iota/iri/utils/thread/ReportingExecutorService.java
+++ b/src/main/java/com/iota/iri/utils/thread/ReportingExecutorService.java
@@ -1,36 +1,48 @@
package com.iota.iri.utils.thread;
/**
+ *
* This interface defines a contract for {@link java.util.concurrent.ExecutorService}s that makes them call a
- * "reporting" method whenever an important event occurs.
- *
+ * "reporting" method whenever an important event occurs.
+ *
+ *
* This way a child class extending these kind of {@link java.util.concurrent.ExecutorService}s can "hook" into these
- * events by overriding the specific method and add additional logic like logging or debugging capabilities.
+ * events by overriding the specific method and add additional logic like logging or debugging capabilities.
+ *
*/
public interface ReportingExecutorService {
/**
- * This method gets called whenever a new task is scheduled to run.
- *
+ *
+ * This method gets called whenever a new task is scheduled to run.
+ *
+ *
* In contrast to {@link #onStartTask(TaskDetails)} this method gets called only once for "recurring" tasks that are
- * scheduled to run in pre-defined intervals.
+ * scheduled to run in pre-defined intervals.
+ *
*
* @param taskDetails object containing details about this task
*/
void onScheduleTask(TaskDetails taskDetails);
/**
- * This method gets called whenever a task is started.
- *
- * For recurring tasks it is called multiple times.
+ *
+ * This method gets called whenever a task is started.
+ *
+ *
+ * For recurring tasks it is called multiple times.
+ *
*
* @param taskDetails object containing details about this task
*/
void onStartTask(TaskDetails taskDetails);
/**
- * This method gets called whenever a task is finished.
- *
- * For recurring tasks it is called multiple times.
+ *
+ * This method gets called whenever a task is finished.
+ *
+ *
+ * For recurring tasks it is called multiple times.
+ *
*
* @param taskDetails object containing details about this task
* @param error {@link Exception} that caused the task to complete
@@ -38,20 +50,26 @@ public interface ReportingExecutorService {
void onFinishTask(TaskDetails taskDetails, Throwable error);
/**
+ *
* This method gets called whenever a task is cancelled through its {@link java.util.concurrent.Future} or through
- * the shutdown methods of the {@link java.util.concurrent.ExecutorService}.
- *
- * It only gets called once for every task.
+ * the shutdown methods of the {@link java.util.concurrent.ExecutorService}.
+ *
+ *
+ * It only gets called once for every task.
+ *
*
* @param taskDetails object containing details about this task
*/
void onCancelTask(TaskDetails taskDetails);
/**
- * This method gets called whenever a task completes.
- *
+ *
+ * This method gets called whenever a task completes.
+ *
+ *
* This can be through either raising an exception, cancelling from the outside or by simply terminating in a normal
- * manner. For recurring tasks this only gets called once.
+ * manner. For recurring tasks this only gets called once.
+ *
*
* @param taskDetails object containing details about this task
* @param error {@link Exception} that caused the task to complete
diff --git a/src/main/java/com/iota/iri/utils/thread/SilentScheduledExecutorService.java b/src/main/java/com/iota/iri/utils/thread/SilentScheduledExecutorService.java
index 8d29e044f1..0ad4dc8308 100644
--- a/src/main/java/com/iota/iri/utils/thread/SilentScheduledExecutorService.java
+++ b/src/main/java/com/iota/iri/utils/thread/SilentScheduledExecutorService.java
@@ -5,17 +5,20 @@
import java.util.concurrent.*;
/**
+ *
* This interface extends the {@link ScheduledExecutorService} by providing additional methods to enqueue tasks without
- * throwing a {@link RejectedExecutionException} exception.
- *
+ * throwing a {@link RejectedExecutionException} exception.
+ *
+ *
* This can be useful when preventing additional tasks to run is no error but an intended design decision in the
* implementing class. In these cases raising an exception and catching it would cause too much unnecessary overhead
- * (using {@link Exception}s for control flow is an anti pattern).
+ * (using {@link Exception}s for control flow is an anti pattern).
+ *
*/
public interface SilentScheduledExecutorService extends ScheduledExecutorService {
/**
* Does the same as {@link ScheduledExecutorService#schedule(Runnable, long, TimeUnit)} but returns {@code null}
- * instead of throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
+ * instead of throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
*
* @param command the task to execute
* @param delay the time from now to delay execution
@@ -29,7 +32,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#schedule(Callable, long, TimeUnit)} but returns {@code null}
* instead of throwing a {@link java.util.concurrent.RejectedExecutionException} if the task cannot be scheduled for
- * execution.
+ * execution.
*
* @param callable the function to execute
* @param delay the time from now to delay execution
@@ -44,7 +47,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#scheduleAtFixedRate(Runnable, long, long, TimeUnit)} but returns
* {@code null} instead of throwing a {@link RejectedExecutionException} if the task cannot be scheduled for
- * execution.
+ * execution.
*
* @param command the task to execute
* @param initialDelay the time to delay first execution
@@ -60,7 +63,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as
* {@link ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)} but returns {@code null}
- * instead of throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
+ * instead of throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
*
* @param command the task to execute
* @param initialDelay the time to delay first execution
@@ -75,7 +78,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#submit(Callable)} but returns {@code null} instead of throwing a
- * {@link RejectedExecutionException} if the task cannot be scheduled for execution.
+ * {@link RejectedExecutionException} if the task cannot be scheduled for execution.
*
* @param task the task to submit
* @param the type of the task's result
@@ -86,7 +89,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#submit(Runnable)} but returns {@code null} instead of throwing a
- * {@link RejectedExecutionException} if the task cannot be scheduled for execution.
+ * {@link RejectedExecutionException} if the task cannot be scheduled for execution.
*
* @param task the task to submit
* @return a Future representing pending completion of the task / {@code null} if the task cannot be scheduled for
@@ -97,7 +100,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#submit(Runnable, Object)} but returns {@code null} instead of
- * throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
+ * throwing a {@link RejectedExecutionException} if the task cannot be scheduled for execution.
*
* @param task the task to submit
* @param result the result to return
@@ -110,7 +113,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#invokeAll(Collection)} but returns {@code null} instead of
- * throwing a {@link RejectedExecutionException} if any task cannot be scheduled for execution.
+ * throwing a {@link RejectedExecutionException} if any task cannot be scheduled for execution.
*
* @param tasks the collection of tasks
* @param the type of the values returned from the tasks
@@ -124,7 +127,7 @@ public interface SilentScheduledExecutorService extends ScheduledExecutorService
/**
* Does the same as {@link ScheduledExecutorService#invokeAll(Collection, long, TimeUnit)} but returns {@code null}
- * instead of throwing a {@link RejectedExecutionException} if any task cannot be scheduled for execution.
+ * instead of throwing a {@link RejectedExecutionException} if any task cannot be scheduled for execution.
*
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
@@ -142,7 +145,7 @@ List> silentInvokeAll(Collection> tasks, lon
/**
* Does the same as {@link ScheduledExecutorService#invokeAny(Collection)} but returns {@code null} instead of
- * throwing a {@link RejectedExecutionException} if tasks cannot be scheduled for execution.
+ * throwing a {@link RejectedExecutionException} if tasks cannot be scheduled for execution.
*
* @param tasks the collection of tasks
* @param the type of the values returned from the tasks
@@ -156,7 +159,7 @@ List> silentInvokeAll(Collection> tasks, lon
/**
* Does the same as {@link ScheduledExecutorService#invokeAny(Collection, long, TimeUnit)} but returns {@code null}
- * instead of throwing a {@link RejectedExecutionException} if tasks cannot be scheduled for execution.
+ * instead of throwing a {@link RejectedExecutionException} if tasks cannot be scheduled for execution.
*
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
@@ -172,7 +175,7 @@ List> silentInvokeAll(Collection> tasks, lon
/**
* Does the same as {@link ScheduledExecutorService#execute(Runnable)} but doesn't throw a
- * {@link RejectedExecutionException} if this task cannot be accepted for execution.
+ * {@link RejectedExecutionException} if this task cannot be accepted for execution.
*
* @param command the runnable task
* @throws NullPointerException if command is null
diff --git a/src/main/java/com/iota/iri/utils/thread/TaskDetails.java b/src/main/java/com/iota/iri/utils/thread/TaskDetails.java
index 3fe30de012..e6c72f9ca7 100644
--- a/src/main/java/com/iota/iri/utils/thread/TaskDetails.java
+++ b/src/main/java/com/iota/iri/utils/thread/TaskDetails.java
@@ -5,58 +5,64 @@
import java.util.concurrent.atomic.AtomicInteger;
/**
+ *
* This class represents a container for the metadata of a task that was scheduled through an
- * {@link java.util.concurrent.ExecutorService} that implements the {@link ReportingExecutorService} interface.
- *
+ * {@link java.util.concurrent.ExecutorService} that implements the {@link ReportingExecutorService} interface.
+ *
+ *
* It can for example be used to show detailed log messages or even implement more sophisticated features like the
- * {@link BoundedScheduledExecutorService}.
+ * {@link BoundedScheduledExecutorService}.
+ *
*/
public class TaskDetails {
/**
- * Holds the name of the {@link Thread} that created the task.
+ * Holds the name of the {@link Thread} that created the task.
*/
private final String threadName;
/**
* Holds a thread-safe flag that indicates if the task is currently scheduled for execution (false if running or
- * done already).
+ * done already).
*/
private final AtomicBoolean scheduledForExecution;
/**
- * Holds a thread-safe counter for the amount of times this task was executed.
+ * Holds a thread-safe counter for the amount of times this task was executed.
*/
private final AtomicInteger executionCount;
/**
* Holds the initial delay that was provided when scheduling the task (or {@code null} if the task was set to run
- * immediately).
+ * immediately).
*/
private Long delay = null;
/**
- * Holds the interval in which the task is repeated (or {@code null} for non-recurring tasks).
+ * Holds the interval in which the task is repeated (or {@code null} for non-recurring tasks).
*/
private Long interval = null;
/**
* Holds the timeout that a task can take to terminate before it gets interrupted (or {@code null} if none was
- * provided).
+ * provided).
*/
private Long timeout = null;
/**
* Holds the time unit that the other values are denominated in (or {@code null} if no time based values are
- * provided).
+ * provided).
*/
private TimeUnit timeUnit = null;
/**
+ *
* Creates a container for the metadata of a task that was scheduled through an
- * {@link java.util.concurrent.ExecutorService}.
- *
+ * {@link java.util.concurrent.ExecutorService}.
+ *
+ *
* It is automatically initiated with the calling {@link Thread} name, the {@link #scheduledForExecution} flag being
- * set to {@code true} and the {@link #executionCount} being set to 0.
+ * set to {@code true} and the {@link #executionCount} being set to 0.
+ *
*/
public TaskDetails() {
this.threadName = Thread.currentThread().getName();
@@ -65,7 +71,7 @@ public TaskDetails() {
}
/**
- * Getter for the internal {@link #threadName} property.
+ * Getter for the internal {@link #threadName} property.
*
* @return name of the {@link Thread} that scheduled the task.
*/
@@ -74,10 +80,11 @@ public String getThreadName() {
}
/**
- * Getter for the internal {@link #scheduledForExecution} property.
- *
+ * Getter for the internal {@link #scheduledForExecution} property.
+ *
* Note: There is no setter for this property because it returns a mutable object that is not supposed be
- * overwritten.
+ * overwritten.
+ *
*
* @return a thread-safe flag that indicates if the task is currently scheduled for execution
*/
@@ -86,10 +93,11 @@ public AtomicBoolean getScheduledForExecution() {
}
/**
- * Getter for the internal {@link #executionCount} property.
- *
+ * Getter for the internal {@link #executionCount} property.
+ *
* Note: There is no setter for this property because it returns a mutable object that is not supposed be
- * overwritten.
+ * overwritten.
+ *
*
* @return a thread-safe counter for the amount of times this task was executed
*/
@@ -98,7 +106,7 @@ public AtomicInteger getExecutionCount() {
}
/**
- * Setter for the internal {@link #delay} property.
+ * Setter for the internal {@link #delay} property.
*
* @param delay the initial delay that was provided when scheduling the task
* @return the instance of TaskDetails itself to allow the chaining of calls
@@ -110,7 +118,7 @@ public TaskDetails setDelay(Long delay) {
}
/**
- * Getter for the internal {@link #delay} property.
+ * Getter for the internal {@link #delay} property.
*
* @return the initial delay that was provided when scheduling the task (or {@code null} if the task was set to run
* immediately)
@@ -120,7 +128,7 @@ public Long getDelay() {
}
/**
- * Setter for the internal {@link #interval} property.
+ * Setter for the internal {@link #interval} property.
*
* @param interval the interval in which the task is repeated (or {@code null} for non-recurring tasks)
* @return the instance of TaskDetails itself to allow the chaining of calls
@@ -132,7 +140,7 @@ public TaskDetails setInterval(Long interval) {
}
/**
- * Getter for the internal {@link #interval} property.
+ * Getter for the internal {@link #interval} property.
*
* @return the interval in which the task is repeated (or {@code null} for non-recurring tasks)
*/
@@ -141,7 +149,7 @@ public Long getInterval() {
}
/**
- * Setter for the internal {@link #timeout} property.
+ * Setter for the internal {@link #timeout} property.
*
* @param timeout the timeout that a task can take to terminate before it gets interrupted (or {@code null} if none
* was provided)
@@ -154,7 +162,7 @@ public TaskDetails setTimeout(Long timeout) {
}
/**
- * Getter for the internal {@link #timeout} property.
+ * Getter for the internal {@link #timeout} property.
*
* @return the timeout that a task can take to terminate before it gets interrupted (or {@code null} if none was
* provided)
@@ -164,7 +172,7 @@ public Long getTimeout() {
}
/**
- * Setter for the internal {@link #timeUnit} property.
+ * Setter for the internal {@link #timeUnit} property.
*
* @param timeUnit the time unit that the other values are denominated in (or {@code null} if no time based values
* are provided)
@@ -177,7 +185,7 @@ public TaskDetails setTimeUnit(TimeUnit timeUnit) {
}
/**
- * Getter for the internal {@link #timeUnit} property.
+ * Getter for the internal {@link #timeUnit} property.
*
* @return the time unit that the other values are denominated in (or {@code null} if no time based values are
* provided)
diff --git a/src/main/java/com/iota/iri/zmq/MessageQ.java b/src/main/java/com/iota/iri/zmq/MessageQ.java
index 7f5d4e35c9..eacbd391d0 100644
--- a/src/main/java/com/iota/iri/zmq/MessageQ.java
+++ b/src/main/java/com/iota/iri/zmq/MessageQ.java
@@ -31,39 +31,31 @@
* For a complete list and detailed topic specification please refer to the README.md.
*
*/
-public class MessageQ {
+class MessageQ {
private final static Logger LOG = LoggerFactory.getLogger(MessageQ.class);
private final ZMQ.Context context;
private final ZMQ.Socket publisher;
- private boolean enabled = false;
private final ExecutorService publisherService = Executors.newSingleThreadExecutor();
public static MessageQ createWith(ZMQConfig config) {
- return new MessageQ(config.getZmqPort(), config.getZmqIpc(), config.getZmqThreads(), config.isZmqEnabled());
+ return new MessageQ(config);
}
/**
* Creates and starts a ZMQ publisher.
*
- * @param port port the publisher will be bound to
- * @param ipc IPC socket the publisher will be bound to
- * @param nthreads number of threads used by the ZMQ publisher
- * @param enabled boolean enable flag; by default the publisher will not be started
+ * @param config {@link ZMQConfig} that should be used.
*/
- private MessageQ(int port, String ipc, int nthreads, boolean enabled) {
- if (enabled) {
- context = ZMQ.context(nthreads);
- publisher = context.socket(ZMQ.PUB);
- publisher.bind(String.format("tcp://*:%d", port));
- if (ipc != null) {
- publisher.bind(ipc);
- }
- this.enabled = true;
- } else {
- context = null;
- publisher = null;
+ private MessageQ(ZMQConfig config) {
+ context = ZMQ.context(config.getZmqThreads());
+ publisher = context.socket(ZMQ.PUB);
+ if (config.isZmqEnableTcp()) {
+ publisher.bind(String.format("tcp://*:%d", config.getZmqPort()));
+ }
+ if (config.isZmqEnableIpc()) {
+ publisher.bind(config.getZmqIpc());
}
}
@@ -74,10 +66,8 @@ private MessageQ(int port, String ipc, int nthreads, boolean enabled) {
* @param objects arguments referenced by the message body, similar to a format string
*/
public void publish(String message, Object... objects) {
- if (enabled) {
- String toSend = String.format(message, objects);
- publisherService.submit(() -> publisher.send(toSend));
- }
+ String toSend = String.format(message, objects);
+ publisherService.submit(() -> publisher.send(toSend));
}
/**
diff --git a/src/main/java/com/iota/iri/zmq/MessageQueueProvider.java b/src/main/java/com/iota/iri/zmq/MessageQueueProvider.java
new file mode 100644
index 0000000000..065b92a7c7
--- /dev/null
+++ b/src/main/java/com/iota/iri/zmq/MessageQueueProvider.java
@@ -0,0 +1,35 @@
+package com.iota.iri.zmq;
+
+import com.iota.iri.model.Hash;
+import com.iota.iri.model.persistables.Transaction;
+import com.iota.iri.storage.Indexable;
+import com.iota.iri.storage.Persistable;
+
+/**
+ * Publish messages to the MessageQueue.
+ */
+public interface MessageQueueProvider {
+ /**
+ * Publishes the message to the MessageQueue.
+ *
+ * @param message that can be formatted by {@link String#format(String, Object...)}
+ * @param objects that should replace the placeholder in message.
+ * @see String#format(String, Object...)
+ */
+ void publish(String message, Object... objects);
+
+ /**
+ * Publishes the transaction details to the MessageQueue.
+ *
+ * @param model with Transaction details send to the MessageQueue.
+ * @param index {@link Hash} identifier of the {@link Transaction} set
+ * @param item identifying the purpose of the update
+ * @return true when message was send to the MessageQueue
+ */
+ boolean publishTransaction(Persistable model, Indexable index, String item);
+
+ /**
+ * Shutdown the MessageQueue.
+ */
+ void shutdown();
+}
diff --git a/src/main/java/com/iota/iri/storage/ZmqPublishProvider.java b/src/main/java/com/iota/iri/zmq/ZmqMessageQueueProvider.java
similarity index 52%
rename from src/main/java/com/iota/iri/storage/ZmqPublishProvider.java
rename to src/main/java/com/iota/iri/zmq/ZmqMessageQueueProvider.java
index 9425805933..289bce9a6a 100644
--- a/src/main/java/com/iota/iri/storage/ZmqPublishProvider.java
+++ b/src/main/java/com/iota/iri/zmq/ZmqMessageQueueProvider.java
@@ -1,55 +1,34 @@
-package com.iota.iri.storage;
+package com.iota.iri.zmq;
+import com.iota.iri.conf.ZMQConfig;
import com.iota.iri.controllers.TransactionViewModel;
import com.iota.iri.model.Hash;
import com.iota.iri.model.persistables.Transaction;
+import com.iota.iri.storage.Indexable;
+import com.iota.iri.storage.Persistable;
import com.iota.iri.utils.Converter;
-import com.iota.iri.utils.Pair;
-import com.iota.iri.zmq.MessageQ;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class ZmqPublishProvider implements PersistenceProvider {
+/**
+ * Use zeromq to create a MessageQueue that publishes messages.
+ */
+public class ZmqMessageQueueProvider implements MessageQueueProvider {
- private static final Logger log = LoggerFactory.getLogger(ZmqPublishProvider.class);
+ private static final Logger log = LoggerFactory.getLogger(ZmqMessageQueueProvider.class);
private final MessageQ messageQ;
- public ZmqPublishProvider( MessageQ messageQ ) {
- this.messageQ = messageQ;
- }
-
- @Override
- public void init() throws Exception {
-
- }
-
- @Override
- public boolean isAvailable() {
- return false;
- }
-
- @Override
- public void shutdown() {
-
- }
-
- @Override
- public boolean save(Persistable model, Indexable index) throws Exception {
- return false;
- }
-
- @Override
- public void delete(Class model, Indexable index) throws Exception {
-
+ /**
+ * Factory method to create a new ZmqMessageQueue with the given configuration.
+ *
+ * @param configuration with the zmq properties used to create MessageQueue
+ */
+ public ZmqMessageQueueProvider(ZMQConfig configuration) {
+ this.messageQ = MessageQ.createWith(configuration);
}
@Override
- public boolean update(Persistable model, Indexable index, String item) throws Exception {
+ public boolean publishTransaction(Persistable model, Indexable index, String item) {
if(!(model instanceof Transaction)) {
return false;
}
@@ -74,7 +53,7 @@ private void publishTx(TransactionViewModel transactionViewModel) {
txStringBuilder.append(transactionViewModel.getHash()); txStringBuilder.append(" ");
txStringBuilder.append(transactionViewModel.getAddressHash()); txStringBuilder.append(" ");
txStringBuilder.append(String.valueOf(transactionViewModel.value())); txStringBuilder.append(" ");
- txStringBuilder.append(transactionViewModel.getObsoleteTagValue().toString().substring(0,27)); txStringBuilder.append(" ");
+ txStringBuilder.append(transactionViewModel.getObsoleteTagValue().toString(), 0, 27); txStringBuilder.append(" ");
txStringBuilder.append(String.valueOf(transactionViewModel.getTimestamp())); txStringBuilder.append(" ");
txStringBuilder.append(String.valueOf(transactionViewModel.getCurrentIndex())); txStringBuilder.append(" ");
txStringBuilder.append(String.valueOf(transactionViewModel.lastIndex())); txStringBuilder.append(" ");
@@ -82,7 +61,7 @@ private void publishTx(TransactionViewModel transactionViewModel) {
txStringBuilder.append(transactionViewModel.getTrunkTransactionHash()); txStringBuilder.append(" ");
txStringBuilder.append(transactionViewModel.getBranchTransactionHash()); txStringBuilder.append(" ");
txStringBuilder.append(String.valueOf(transactionViewModel.getArrivalTime())); txStringBuilder.append(" ");
- txStringBuilder.append(transactionViewModel.getTagValue().toString().substring(0,27));
+ txStringBuilder.append(transactionViewModel.getTagValue().toString(), 0, 27);
messageQ.publish(txStringBuilder.toString());
} catch (Exception e) {
@@ -106,83 +85,20 @@ private void publishTxTrytes(TransactionViewModel transactionViewModel) {
}
}
+ /**
+ * Publishes the message to the MessageQueue.
+ *
+ * @param message that can be formatted by {@link String#format(String, Object...)}
+ * @param objects that should replace the placeholder in message.
+ * @see String#format(String, Object...)
+ */
@Override
- public boolean exists(Class model, Indexable key) throws Exception {
- return false;
+ public void publish(String message, Object... objects) {
+ this.messageQ.publish(message, objects);
}
@Override
- public Pair latest(Class model, Class indexModel) throws Exception {
- return null;
- }
-
- @Override
- public Set keysWithMissingReferences(Class modelClass, Class otherClass) throws Exception {
- return null;
- }
-
- @Override
- public Persistable get(Class model, Indexable index) throws Exception {
- return null;
- }
-
- @Override
- public boolean mayExist(Class model, Indexable index) throws Exception {
- return false;
- }
-
- @Override
- public long count(Class model) throws Exception {
- return 0;
- }
-
- @Override
- public Set keysStartingWith(Class modelClass, byte[] value) {
- return null;
- }
-
- @Override
- public Persistable seek(Class model, byte[] key) throws Exception {
- return null;
- }
-
- @Override
- public Pair next(Class model, Indexable index) throws Exception {
- return null;
- }
-
- @Override
- public Pair previous(Class model, Indexable index) throws Exception {
- return null;
- }
-
- @Override
- public Pair first(Class model, Class indexModel) throws Exception {
- return null;
- }
-
- @Override
- public boolean saveBatch(List> models) throws Exception {
- return false;
- }
-
- @Override
- public void deleteBatch(Collection>> models) throws Exception {
-
- }
-
- @Override
- public void clear(Class column) throws Exception {
-
- }
-
- @Override
- public void clearMetadata(Class column) throws Exception {
-
- }
-
- @Override
- public List loadAllKeysFromTable(Class model) {
- return null;
+ public void shutdown() {
+ this.messageQ.shutdown();
}
}
\ No newline at end of file
diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml
index 0ce840ac49..85a08b9c40 100644
--- a/src/main/resources/logback.xml
+++ b/src/main/resources/logback.xml
@@ -24,7 +24,7 @@
DENY
- %d{MM/dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+ %d{MM/dd HH:mm:ss.SSS} [%thread] %-5level %logger{0}:%L - %msg%n
@@ -37,7 +37,7 @@
DENY
- %d{MM/dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+ %d{MM/dd HH:mm:ss.SSS} [%thread] %-5level %logger{0}:%L - %msg%n
@@ -46,4 +46,4 @@
>> ixiAPI =
+ (Map>>) ixiApiField.get(ixi);
+ ixiAPI.put("IXI", new HashMap<>());
}
/**
@@ -70,7 +81,7 @@ public void processCommandEmpty() {
}
/**
- * If an does not match the command pattern, expect an unknown command error message.
+ * If the given command does not exist, expect an unknown command error message.
*/
@Test
public void processCommandUnknown() {
@@ -79,4 +90,13 @@ public void processCommandUnknown() {
assertTrue("Wrong error message returned in response", response.toString().contains("Command [unknown] is unknown"));
}
-}
\ No newline at end of file
+ /**
+ * If an IXI module does not have the given command, expect an unknown command error message.
+ */
+ @Test
+ public void processIXICommandUnknown() {
+ AbstractResponse response = ixi.processCommand("IXI.unknown", null);
+ assertThat("Wrong type of response", response, CoreMatchers.instanceOf(ErrorResponse.class));
+ assertTrue("Wrong error message returned in response", response.toString().contains("Command [IXI.unknown] is unknown"));
+ }
+}
diff --git a/src/test/java/com/iota/iri/TangleMockUtils.java b/src/test/java/com/iota/iri/TangleMockUtils.java
index 1bee23d7fb..49637ab492 100644
--- a/src/test/java/com/iota/iri/TangleMockUtils.java
+++ b/src/test/java/com/iota/iri/TangleMockUtils.java
@@ -17,25 +17,31 @@
import java.util.*;
/**
- * Contains utilities that help to mock the retrieval of database entries from the tangle.
- *
+ * Contains utilities that help to mock the retrieval of database entries from the tangle.
+ *
+ *
* Mocking the tangle allows us to write unit tests that perform much faster than spinning up a new database for every
- * test.
+ * test.
+ *
*/
public class TangleMockUtils {
//region [mockMilestone] ///////////////////////////////////////////////////////////////////////////////////////////
/**
- * Registers a {@link Milestone} in the mocked tangle that can consequently be accessed by the tested classes.
- *
+ *
+ * Registers a {@link Milestone} in the mocked tangle that can consequently be accessed by the tested classes.
+ *
+ *
* It first creates the {@link Milestone} with the given details and then mocks the retrieval methods of the tangle
* to return this object. In addition to mocking the specific retrieval method for the given hash, we also mock the
* retrieval method for the "latest" entity so the mocked tangle returns the elements in the order that they were
- * mocked / created (which allows the mocked tangle to behave just like a normal one).
- *
+ * mocked / created (which allows the mocked tangle to behave just like a normal one).
+ *
+ *
* Note: We return the mocked object which allows us to set additional fields or modify it after "injecting" it into
- * the mocked tangle.
- *
+ * the mocked tangle.
+ *
+ *
* @param tangle mocked tangle object that shall retrieve a milestone object when being queried for it
* @param hash transaction hash of the milestone
* @param index milestone index of the milestone
@@ -72,7 +78,7 @@ public static List mockValidBundle(Tangle tangle,
address = TransactionTestUtils.nextWord(address);
Converter.trits(address, trits, TransactionViewModel.ADDRESS_TRINARY_OFFSET);
if (tx != null) {
- TransactionTestUtils.getTransactionTritsWithTrunkAndBranch(trits, tx.getHash(), Hash.NULL_HASH);
+ TransactionTestUtils.getTransactionTritsWithTrunkAndBranchTrits(trits, tx.getHash(), Hash.NULL_HASH);
}
TransactionTestUtils.setLastIndex(trits, lastIndex);
TransactionTestUtils.setCurrentIndex(trits, currentIndex--);
@@ -111,7 +117,7 @@ public static List mockValidBundle(Tangle tangle,
* This transaction is returned when the hash is asked to load in the tangle object
*
* @param tangle mocked tangle object that shall retrieve a milestone object when being queried for it
- * @param hash
+ * @param hash transaction hash
* @return The newly created (empty) transaction
*/
public static Transaction mockTransaction(Tangle tangle, Hash hash) {
diff --git a/src/test/java/com/iota/iri/TransactionTestUtils.java b/src/test/java/com/iota/iri/TransactionTestUtils.java
index c9200f4531..fc5b148f08 100644
--- a/src/test/java/com/iota/iri/TransactionTestUtils.java
+++ b/src/test/java/com/iota/iri/TransactionTestUtils.java
@@ -8,7 +8,6 @@
import com.iota.iri.model.persistables.Transaction;
import com.iota.iri.utils.Converter;
-import java.util.Arrays;
import java.util.Random;
import org.apache.commons.lang3.StringUtils;
@@ -26,7 +25,13 @@ public class TransactionTestUtils {
public static void setCurrentIndex(TransactionViewModel tx, long currentIndex) {
setCurrentIndex(tx.trits(), currentIndex);
}
-
+
+ /**
+ * Updates the transaction index trits.
+ *
+ * @param trits The trits to update
+ * @param currentIndex The new index to set the transaction to
+ */
public static void setCurrentIndex(byte[] trits, long currentIndex) {
Converter.copyTrits(currentIndex, trits, TransactionViewModel.CURRENT_INDEX_TRINARY_OFFSET,
TransactionViewModel.CURRENT_INDEX_TRINARY_SIZE);
@@ -42,21 +47,27 @@ public static void setLastIndex(TransactionViewModel tx, long lastIndex) {
setLastIndex(tx.trits(), lastIndex);
}
+ /**
+ * Updates the last transaction index trits.
+ *
+ * @param trits The trits to update
+ * @param currentIndex The new last index to set the transaction to
+ */
public static void setLastIndex(byte[] trits, long lastIndex) {
Converter.copyTrits(lastIndex, trits, TransactionViewModel.LAST_INDEX_TRINARY_OFFSET,
TransactionViewModel.LAST_INDEX_TRINARY_SIZE);
}
/**
- * Generates a random transaction with a random hash.
+ * Generates a transaction with a hash.
* Transaction last and current index are set to the index provided.
*
* @param index The index to set the transaction to
- * @return A random transaction which is located on the end of its (nonexistent) bundle
+ * @return A transaction which is located on the end of its (nonexistent) bundle
*/
public static TransactionViewModel createBundleHead(int index) {
- TransactionViewModel tx = new TransactionViewModel(getRandomTransactionTrits(), getRandomTransactionHash());
+ TransactionViewModel tx = new TransactionViewModel(getTransactionTrits(), getTransactionHash());
setLastIndex(tx, index);
setCurrentIndex(tx, index);
return tx;
@@ -71,14 +82,14 @@ public static TransactionViewModel createBundleHead(int index) {
* @return A transaction in the same bundle as trunk, with its index 1 below trunk index
*/
public static TransactionViewModel createTransactionWithTrunkBundleHash(TransactionViewModel trunkTx, Hash branchHash) {
- byte[] txTrits = getTransactionWithTrunkAndBranch(trunkTx.getHash(), branchHash);
+ byte[] txTrits = getTransactionTritsWithTrunkAndBranch(trunkTx.getHash(), branchHash);
setCurrentIndex(txTrits, trunkTx.getCurrentIndex() - 1);
setLastIndex(txTrits, trunkTx.lastIndex());
System.arraycopy(trunkTx.trits(), TransactionViewModel.BUNDLE_TRINARY_OFFSET, txTrits,
TransactionViewModel.BUNDLE_TRINARY_OFFSET, TransactionViewModel.BUNDLE_TRINARY_SIZE);
TransactionViewModel tx = new TransactionViewModel(
txTrits,
- getRandomTransactionHash());
+ getTransactionHash());
return tx;
}
@@ -97,6 +108,13 @@ public static TransactionViewModel createTransactionWithTrytes(String trytes) {
return createTransactionFromTrits(trits);
}
+ /**
+ * Creates a {@link TransactionViewModel} from the supplied trits.
+ * Trits are not checked for size and content.
+ *
+ * @param trits The transaction trits
+ * @return The transaction
+ */
public static TransactionViewModel createTransactionFromTrits(byte[] trits) {
return new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
}
@@ -113,7 +131,7 @@ public static TransactionViewModel createTransactionFromTrits(byte[] trits) {
*/
public static TransactionViewModel createTransactionWithTrunkAndBranch(String trytes, Hash trunk, Hash branch) {
byte[] trits = createTransactionWithTrunkAndBranchTrits(trytes, trunk, branch);
- return new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
+ return createTransactionFromTrits(trits);
}
/**
@@ -128,19 +146,20 @@ public static TransactionViewModel createTransactionWithTrunkAndBranch(String tr
public static byte[] createTransactionWithTrunkAndBranchTrits(String trytes, Hash trunk, Hash branch) {
String expandedTrytes = expandTrytes(trytes);
byte[] trits = Converter.allocatingTritsFromTrytes(expandedTrytes);
- return getTransactionTritsWithTrunkAndBranch(trits, trunk, branch);
+ return getTransactionTritsWithTrunkAndBranchTrits(trits, trunk, branch);
}
/**
- * Generates random transaction trits with the provided trytes, trunk and hash.
+ * Generates transaction trits with the provided trytes, trunk and hash.
+ * No validation is done on the resulting trits, so fields are not valid except trunk and branch.
*
* @param trunk The trunk transaction hash
* @param branch The branch transaction hash
* @return The transaction trits
*/
- public static byte[] getTransactionWithTrunkAndBranch(Hash trunk, Hash branch) {
- byte[] trits = new byte[TransactionViewModel.TRINARY_SIZE];
- return getTransactionTritsWithTrunkAndBranch(trits, trunk, branch);
+ public static byte[] getTransactionTritsWithTrunkAndBranch(Hash trunk, Hash branch) {
+ byte[] trits = getTransactionTrits();
+ return getTransactionTritsWithTrunkAndBranchTrits(trits, trunk, branch);
}
/**
@@ -150,7 +169,7 @@ public static byte[] getTransactionWithTrunkAndBranch(Hash trunk, Hash branch) {
* @param branch The branch transaction hash
* @return trits The transaction trits
*/
- public static byte[] getTransactionTritsWithTrunkAndBranch(byte[] trits, Hash trunk, Hash branch) {
+ public static byte[] getTransactionTritsWithTrunkAndBranchTrits(byte[] trits, Hash trunk, Hash branch) {
System.arraycopy(trunk.trits(), 0, trits, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_OFFSET,
TransactionViewModel.TRUNK_TRANSACTION_TRINARY_SIZE);
System.arraycopy(branch.trits(), 0, trits, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET,
@@ -184,22 +203,22 @@ else if (chars[i] != 'Z') {
}
/**
- * Generates a random transaction.
+ * Generates a transaction.
*
* @return The transaction
*/
- public static Transaction getRandomTransaction() {
- byte[] trits = getRandomTransactionTrits();
+ public static Transaction getTransaction() {
+ byte[] trits = getTransactionTrits();
return buildTransaction(trits);
}
/**
- * Generates random trits for a transaction.
+ * Generates trits for a transaction.
*
* @return The transaction trits
*/
- public static byte[] getRandomTransactionTrits() {
- return getRandomTrits(TransactionViewModel.TRINARY_SIZE);
+ public static byte[] getTransactionTrits() {
+ return getTrits(TransactionViewModel.TRINARY_SIZE);
}
/**
@@ -209,34 +228,58 @@ public static byte[] getRandomTransactionTrits() {
*/
public static Transaction get9Transaction() {
byte[] trits = new byte[TransactionViewModel.TRINARY_SIZE];
- Arrays.fill(trits, (byte) 0);
+ for (int i = 0; i < trits.length; i++) {
+ trits[i] = 0;
+ }
return buildTransaction(trits);
}
+
+
+ /**
+ * Generates a transaction with trunk and hash.
+ *
+ * @param trunk The trunk transaction hash
+ * @param branch The branch transaction hash
+ * @return The transaction
+ */
+ public static Transaction createTransactionWithTrunkAndBranch(Hash trunk, Hash branch) {
+ byte[] trits = getTrits(TransactionViewModel.TRINARY_SIZE);
+ getTransactionTritsWithTrunkAndBranchTrits(trits, trunk, branch);
+ return buildTransaction(trits);
+ }
/**
- * Generates random trits for a transaction.
+ * Generates trits for a hash.
*
* @return The transaction hash
*/
- public static Hash getRandomTransactionHash() {
- byte[] out = getRandomTrits(Hash.SIZE_IN_TRITS);
+ public static Hash getTransactionHash() {
+ byte[] out = getTrits(Hash.SIZE_IN_TRITS);
return HashFactory.TRANSACTION.create(out);
}
/**
* Builds a transaction by transforming trits to bytes.
+ * Make sure the trits are in the correct order (TVM.trits())
*
* @param trits The trits to build the transaction
* @return The created transaction
*/
- public static Transaction buildTransaction(byte[] trits) {
- Transaction transaction = new Transaction();
+ public static Transaction buildTransaction(byte[] trits) {
+ TransactionViewModel TVM = new TransactionViewModel(trits, Hash.NULL_HASH);
+
+ //Getters obtain and load values from TVM trits ("lazy loading")
+ TVM.getAddressHash();
+ TVM.getTrunkTransactionHash();
+ TVM.getBranchTransactionHash();
+ TVM.getBundleHash();
+ TVM.getTagValue();
+ TVM.getObsoleteTagValue();
+ TVM.setAttachmentData();
+ TVM.setMetadata();
- transaction.bytes = Converter.allocateBytesForTrits(trits.length);
- Converter.bytes(trits, 0, transaction.bytes, 0, trits.length);
- transaction.readMetadata( transaction.bytes);
- return transaction;
+ return TVM.getTransaction();
}
/**
@@ -250,12 +293,13 @@ private static String expandTrytes(String trytes) {
}
/**
- * Generates random trits of specified size.
+ * Generates 'random' trits of specified size.
+ * Not truly random as we always use the same seed.
*
* @param size the amount of trits to generate
* @return The trits
*/
- private static byte[] getRandomTrits(int size) {
+ private static byte[] getTrits(int size) {
byte[] out = new byte[size];
for(int i = 0; i < out.length; i++) {
diff --git a/src/test/java/com/iota/iri/TransactionValidatorTest.java b/src/test/java/com/iota/iri/TransactionValidatorTest.java
index f70c29d516..1ee6f751f6 100644
--- a/src/test/java/com/iota/iri/TransactionValidatorTest.java
+++ b/src/test/java/com/iota/iri/TransactionValidatorTest.java
@@ -11,12 +11,10 @@
import com.iota.iri.storage.Tangle;
import com.iota.iri.storage.rocksDB.RocksDBPersistenceProvider;
import com.iota.iri.utils.Converter;
-import com.iota.iri.zmq.MessageQ;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
-import org.mockito.Mockito;
import static com.iota.iri.TransactionTestUtils.*;
import static org.junit.Assert.assertFalse;
@@ -42,8 +40,7 @@ public static void setUp() throws Exception {
dbFolder.getRoot().getAbsolutePath(), logFolder.getRoot().getAbsolutePath(),1000, Tangle.COLUMN_FAMILIES, Tangle.METADATA_COLUMN_FAMILY));
tangle.init();
TipsViewModel tipsViewModel = new TipsViewModel();
- MessageQ messageQ = Mockito.mock(MessageQ.class);
- TransactionRequester txRequester = new TransactionRequester(tangle, snapshotProvider, messageQ);
+ TransactionRequester txRequester = new TransactionRequester(tangle, snapshotProvider);
txValidator = new TransactionValidator(tangle, snapshotProvider, tipsViewModel, txRequester);
txValidator.setMwm(false, MAINNET_MWM);
}
@@ -66,20 +63,20 @@ public void testMinMwm() throws InterruptedException {
@Test
public void validateTrits() {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Converter.copyTrits(0, trits, 0, trits.length);
txValidator.validateTrits(trits, MAINNET_MWM);
}
@Test(expected = RuntimeException.class)
public void validateTritsWithInvalidMetadata() {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
txValidator.validateTrits(trits, MAINNET_MWM);
}
@Test
public void validateBytesWithNewCurl() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Converter.copyTrits(0, trits, 0, trits.length);
byte[] bytes = Converter.allocateBytesForTrits(trits.length);
Converter.bytes(trits, 0, bytes, 0, trits.length);
@@ -102,7 +99,7 @@ public void verifyTxIsNotSolid() throws Exception {
@Test
public void addSolidTransactionWithoutErrors() {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Converter.copyTrits(0, trits, 0, trits.length);
txValidator.addSolidTransaction(TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
}
@@ -116,7 +113,7 @@ private TransactionViewModel getTxWithBranchAndTrunk() throws Exception {
trunkTx = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
branchTx = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
- byte[] childTx = getRandomTransactionTrits();
+ byte[] childTx = getTransactionTrits();
System.arraycopy(trunkTx.getHash().trits(), 0, childTx, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_SIZE);
System.arraycopy(branchTx.getHash().trits(), 0, childTx, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_SIZE);
tx = new TransactionViewModel(childTx, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, childTx));
@@ -165,25 +162,25 @@ public void testTransactionPropagation() throws Exception {
@Test
public void testTransactionPropagationFailure() throws Exception {
- TransactionViewModel leftChildLeaf = new TransactionViewModel(getRandomTransactionTrits(), getRandomTransactionHash());
+ TransactionViewModel leftChildLeaf = new TransactionViewModel(getTransactionTrits(), getTransactionHash());
leftChildLeaf.updateSolid(true);
leftChildLeaf.store(tangle, snapshotProvider.getInitialSnapshot());
- TransactionViewModel rightChildLeaf = new TransactionViewModel(getRandomTransactionTrits(), getRandomTransactionHash());
+ TransactionViewModel rightChildLeaf = new TransactionViewModel(getTransactionTrits(), getTransactionHash());
rightChildLeaf.updateSolid(true);
rightChildLeaf.store(tangle, snapshotProvider.getInitialSnapshot());
- TransactionViewModel parent = new TransactionViewModel(getTransactionWithTrunkAndBranch(leftChildLeaf.getHash(),
- rightChildLeaf.getHash()), getRandomTransactionHash());
+ TransactionViewModel parent = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(leftChildLeaf.getHash(),
+ rightChildLeaf.getHash()), getTransactionHash());
parent.updateSolid(false);
parent.store(tangle, snapshotProvider.getInitialSnapshot());
- TransactionViewModel parentSibling = new TransactionViewModel(getRandomTransactionTrits(), getRandomTransactionHash());
+ TransactionViewModel parentSibling = new TransactionViewModel(getTransactionTrits(), getTransactionHash());
parentSibling.updateSolid(false);
parentSibling.store(tangle, snapshotProvider.getInitialSnapshot());
- TransactionViewModel grandParent = new TransactionViewModel(getTransactionWithTrunkAndBranch(parent.getHash(),
- parentSibling.getHash()), getRandomTransactionHash());
+ TransactionViewModel grandParent = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(parent.getHash(),
+ parentSibling.getHash()), getTransactionHash());
grandParent.updateSolid(false);
grandParent.store(tangle, snapshotProvider.getInitialSnapshot());
@@ -199,7 +196,7 @@ public void testTransactionPropagationFailure() throws Exception {
}
private TransactionViewModel getTxWithoutBranchAndTrunk() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
TransactionViewModel tx = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
tx.store(tangle, snapshotProvider.getInitialSnapshot());
diff --git a/src/test/java/com/iota/iri/benchmarks/BenchmarkRunner.java b/src/test/java/com/iota/iri/benchmarks/BenchmarkRunner.java
index a5954a2ad6..ef4a22af9c 100644
--- a/src/test/java/com/iota/iri/benchmarks/BenchmarkRunner.java
+++ b/src/test/java/com/iota/iri/benchmarks/BenchmarkRunner.java
@@ -28,4 +28,19 @@ public void launchDbBenchmarks() throws RunnerException {
//possible to do assertions over run results
new Runner(opts).run();
}
+
+ @Test
+ public void launchCryptoBenchmark() throws RunnerException {
+ Options opts = new OptionsBuilder()
+ .include(this.getClass().getPackage().getName() + ".crypto")
+ .mode(Mode.Throughput)
+ .timeUnit(TimeUnit.SECONDS)
+ .warmupIterations(5)
+ .forks(1)
+ .measurementIterations(10)
+ .shouldFailOnError(true)
+ .shouldDoGC(false)
+ .build();
+ new Runner(opts).run();
+ }
}
diff --git a/src/test/java/com/iota/iri/benchmarks/crypto/CurlBenchmark.java b/src/test/java/com/iota/iri/benchmarks/crypto/CurlBenchmark.java
new file mode 100644
index 0000000000..341ab3d23a
--- /dev/null
+++ b/src/test/java/com/iota/iri/benchmarks/crypto/CurlBenchmark.java
@@ -0,0 +1,62 @@
+package com.iota.iri.benchmarks.crypto;
+
+import com.iota.iri.crypto.Curl;
+import com.iota.iri.crypto.SpongeFactory;
+import com.iota.iri.utils.Converter;
+import com.iota.iri.utils.Pair;
+import org.junit.Assert;
+import org.openjdk.jmh.annotations.Benchmark;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class CurlBenchmark {
+ private final static String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
+ private final static String HASH = "TIXEPIEYMGURTQ9ABVYVQSWMNGCVQFASMFAEQWUZCLIWLCDIGYVXOEJBBEMZOIHAYSUQMEFOGZBXUMHQW";
+
+ /**
+ * Benchmark absorb and squeeze methods of Curl 81 hash function.
+ */
+ @Benchmark
+ public void curl() {
+ int size = 8019;
+ byte[] in_trits = new byte[size];
+ byte[] hash_trits = new byte[Curl.HASH_LENGTH];
+ Converter.trits(TRYTES, in_trits, 0);
+ Curl curl = (Curl) SpongeFactory.create(SpongeFactory.Mode.CURLP81);
+ curl.absorb(in_trits, 0, in_trits.length);
+ curl.squeeze(hash_trits, 0, Curl.HASH_LENGTH);
+ String out_trytes = Converter.trytes(hash_trits);
+ Assert.assertEquals(HASH, out_trytes);
+ }
+
+ /**
+ * Benchmark absorb and squeeze methods of pair Curl 81 hash function.
+ */
+ @Benchmark
+ public void pairCurl() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
+ int size = 8019;
+ byte[] in_trits = new byte[size];
+ Pair hashPair = new Pair<>(new long[Curl.HASH_LENGTH], new long[Curl.HASH_LENGTH]);
+ Converter.trits(TRYTES, in_trits, 0);
+ // Using reflection to benchmark private, non-production code.
+ // Reflection doesn't have impact on benchmark result (this has been tested)
+ // Please remove this code when method are public
+ Class curlClass = Curl.class;
+ Constructor curlConstructor = curlClass.getDeclaredConstructor(boolean.class, SpongeFactory.Mode.class);
+ curlConstructor.setAccessible(true);
+ Curl curl = curlConstructor.newInstance(true, SpongeFactory.Mode.CURLP81);
+ Method pairAbsorb = curlClass.getDeclaredMethod("absorb", Pair.class, int.class, int.class);
+ Method pairSqueeze = curlClass.getDeclaredMethod("squeeze", Pair.class, int.class, int.class);
+ pairAbsorb.setAccessible(true);
+ pairSqueeze.setAccessible(true);
+
+ pairAbsorb.invoke(curl, Converter.longPair(in_trits), 0, in_trits.length);
+ pairSqueeze.invoke(curl, hashPair, 0, Curl.HASH_LENGTH);
+ byte[] hash_trits = Converter.trits(hashPair.low, hashPair.hi);
+ String out_trytes = Converter.trytes(hash_trits);
+ Assert.assertEquals(HASH, out_trytes);
+ }
+
+}
diff --git a/src/test/java/com/iota/iri/benchmarks/crypto/PearlDiverBenchmark.java b/src/test/java/com/iota/iri/benchmarks/crypto/PearlDiverBenchmark.java
new file mode 100644
index 0000000000..9d36eb1ed3
--- /dev/null
+++ b/src/test/java/com/iota/iri/benchmarks/crypto/PearlDiverBenchmark.java
@@ -0,0 +1,23 @@
+package com.iota.iri.benchmarks.crypto;
+
+import com.iota.iri.crypto.PearlDiver;
+import com.iota.iri.utils.Converter;
+import org.openjdk.jmh.annotations.Benchmark;
+
+public class PearlDiverBenchmark {
+ private static final int MIN_WEIGHT_MAGNITUDE = 9;
+ private static final int NUM_CORES = -1; // use n-1 cores
+ private static final String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
+
+ /**
+ * Benchmark Pearl Diver search function.
+ */
+ @Benchmark
+ public void search() {
+ PearlDiver pearlDiver = new PearlDiver();
+ byte[] myTrits = Converter.allocateTritsForTrytes(TRYTES.length());
+ Converter.trits(TRYTES, myTrits, 0);
+ pearlDiver.search(myTrits, MIN_WEIGHT_MAGNITUDE, NUM_CORES);
+ }
+
+}
diff --git a/src/test/java/com/iota/iri/conf/ConfigTest.java b/src/test/java/com/iota/iri/conf/ConfigTest.java
index f865147f8e..c341615db0 100644
--- a/src/test/java/com/iota/iri/conf/ConfigTest.java
+++ b/src/test/java/com/iota/iri/conf/ConfigTest.java
@@ -19,8 +19,11 @@
import java.io.IOException;
import java.io.Writer;
import java.lang.reflect.Method;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Collection;
+import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -51,7 +54,7 @@ public static void tearDownAfterClass() throws IOException {
Test that iterates over common configs. It also attempts to check different types of types (double, boolean, string)
*/
@Test
- public void testArgsParsingMainnet() {
+ public void testArgsParsingMainnet() throws UnknownHostException {
String[] args = {
"-p", "14000",
"-u", "13000",
@@ -59,6 +62,7 @@ public void testArgsParsingMainnet() {
"-n", "udp://neighbor1 neighbor, tcp://neighbor2",
"--api-host", "1.1.1.1",
"--remote-limit-api", "call1 call2, call3",
+ "--remote-trusted-api-hosts", "192.168.0.55, 10.0.0.10",
"--max-find-transactions", "500",
"--max-requests-list", "1000",
"--max-get-trytes", "4000",
@@ -72,11 +76,11 @@ public void testArgsParsingMainnet() {
"--ixi-dir", "/ixi",
"--db-path", "/db",
"--db-log-path", "/dblog",
- "--zmq-enabled",
+ "--zmq-enabled", "true",
//we ignore this on mainnet
"--mwm", "4",
"--testnet-coordinator", "TTTTTTTTT",
- "--test-no-coo-validation",
+ "--test-no-coo-validation", "true",
//this should be ignored everywhere
"--fake-config"
};
@@ -92,6 +96,13 @@ public void testArgsParsingMainnet() {
Assert.assertEquals("api host", "1.1.1.1", iotaConfig.getApiHost());
Assert.assertEquals("remote limit api", Arrays.asList("call1", "call2", "call3"),
iotaConfig.getRemoteLimitApi());
+
+ List expectedTrustedApiHosts = Arrays.asList(
+ InetAddress.getByName("192.168.0.55"),
+ InetAddress.getByName("10.0.0.10"),
+ InetAddress.getByName("127.0.0.1"));
+ Assert.assertEquals("remote trusted api hosts", expectedTrustedApiHosts, iotaConfig.getRemoteTrustedApiHosts());
+
Assert.assertEquals("max find transactions", 500, iotaConfig.getMaxFindTransactions());
Assert.assertEquals("max requests list", 1000, iotaConfig.getMaxRequestsList());
Assert.assertEquals("max get trytes", 4000, iotaConfig.getMaxGetTrytes());
@@ -102,7 +113,7 @@ public void testArgsParsingMainnet() {
Assert.assertEquals("max peers", 10, iotaConfig.getMaxPeers());
Assert.assertEquals("dns refresher", false, iotaConfig.isDnsRefresherEnabled());
Assert.assertEquals("dns resolution", false, iotaConfig.isDnsResolutionEnabled());
- Assert.assertEquals("tip solidification", true, iotaConfig.isTipSolidifierEnabled());
+ Assert.assertEquals("tip solidification", false, iotaConfig.isTipSolidifierEnabled());
Assert.assertEquals("ixi-dir", "/ixi", iotaConfig.getIxiDir());
Assert.assertEquals("db path", "/db", iotaConfig.getDbPath());
Assert.assertEquals("zmq enabled", true, iotaConfig.isZmqEnabled());
@@ -115,7 +126,7 @@ public void testArgsParsingMainnet() {
@Test
public void testRemoteFlag() {
- String[] args = {"--remote"};
+ String[] args = {"--remote", "true"};
IotaConfig iotaConfig = ConfigFactory.createIotaConfig(false);
iotaConfig.parseConfigFromArgs(args);
Assert.assertEquals("The api interface should be open to the public", "0.0.0.0", iotaConfig.getApiHost());
@@ -144,11 +155,11 @@ public void testArgsParsingTestnet() {
"--ixi-dir", "/ixi",
"--db-path", "/db",
"--db-log-path", "/dblog",
- "--zmq-enabled",
+ "--zmq-enabled", "true",
//we ignore this on mainnet
"--mwm", "4",
"--testnet-coordinator", "TTTTTTTTT",
- "--testnet-no-coo-validation",
+ "--testnet-no-coo-validation", "true",
//this should be ignored everywhere
"--fake-config"
};
@@ -190,6 +201,7 @@ public void testIniParsingMainnet() throws Exception {
.append("[IRI]").append(System.lineSeparator())
.append("PORT = 17000").append(System.lineSeparator())
.append("NEIGHBORS = udp://neighbor1 neighbor, tcp://neighbor2").append(System.lineSeparator())
+ .append("REMOTE_TRUSTED_API_HOSTS = 192.168.0.55, 10.0.0.10").append(System.lineSeparator())
.append("ZMQ_ENABLED = true").append(System.lineSeparator())
.append("P_REMOVE_REQUEST = 0.4").append(System.lineSeparator())
.append("MWM = 4").append(System.lineSeparator())
@@ -206,6 +218,13 @@ public void testIniParsingMainnet() throws Exception {
Assert.assertEquals("PORT", 17000, iotaConfig.getPort());
Assert.assertEquals("NEIGHBORS", Arrays.asList("udp://neighbor1", "neighbor", "tcp://neighbor2"),
iotaConfig.getNeighbors());
+
+ List expectedTrustedApiHosts = Arrays.asList(
+ InetAddress.getByName("192.168.0.55"),
+ InetAddress.getByName("10.0.0.10"),
+ BaseIotaConfig.Defaults.REMOTE_LIMIT_API_DEFAULT_HOST);
+ Assert.assertEquals("REMOTE_TRUSTED_API_HOSTS", expectedTrustedApiHosts, iotaConfig.getRemoteTrustedApiHosts());
+
Assert.assertEquals("ZMQ_ENABLED", true, iotaConfig.isZmqEnabled());
Assert.assertEquals("P_REMOVE_REQUEST", 0.4d, iotaConfig.getpRemoveRequest(), 0);
Assert.assertNotEquals("MWM", 4, iotaConfig.getMwm());
diff --git a/src/test/java/com/iota/iri/conf/ZMQConfigTest.java b/src/test/java/com/iota/iri/conf/ZMQConfigTest.java
new file mode 100644
index 0000000000..e2caee1feb
--- /dev/null
+++ b/src/test/java/com/iota/iri/conf/ZMQConfigTest.java
@@ -0,0 +1,88 @@
+package com.iota.iri.conf;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class ZMQConfigTest {
+
+ @Test
+ public void isZmqEnabledLegacy() {
+ String[] args = {
+ "--zmq-enabled", "true",
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertTrue("ZMQ must be globally enabled", config.isZmqEnabled());
+ assertTrue("ZMQ TCP must be enabled", config.isZmqEnableTcp());
+ assertTrue("ZMQ IPC must be enabled", config.isZmqEnableIpc());
+ }
+
+ @Test
+ public void isZmqEnabled() {
+ String[] args = {
+ "--zmq-enable-tcp", "true",
+ "--zmq-enable-ipc", "true",
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertTrue("ZMQ must be globally enabled", config.isZmqEnabled());
+ assertTrue("ZMQ TCP must be enabled", config.isZmqEnableTcp());
+ assertTrue("ZMQ IPC must be enabled", config.isZmqEnableIpc());
+ }
+
+ @Test
+ public void isZmqEnableTcp() {
+ String[] args = {
+ "--zmq-enable-tcp", "true"
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertEquals("ZMQ port must be the default port", 5556, config.getZmqPort());
+ assertTrue("ZMQ TCP must be enabled", config.isZmqEnableTcp());
+ }
+
+ @Test
+ public void isZmqEnableIpc() {
+ String[] args = {
+ "--zmq-enable-ipc", "true"
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertEquals("ZMQ ipc must be the default ipc", "ipc://iri", config.getZmqIpc());
+ assertTrue("ZMQ IPC must be enabled", config.isZmqEnableIpc());
+ }
+
+ @Test
+ public void getZmqPort() {
+ String[] args = {
+ "--zmq-port", "8899"
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertTrue("ZMQ TCP must be enabled", config.isZmqEnableTcp());
+ assertEquals("ZMQ port must be overridden", 8899, config.getZmqPort());
+ }
+
+ @Test
+ public void getZmqThreads() {
+ String[] args = {
+ "--zmq-threads", "5"
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertEquals("ZMQ threads must be overridden", 5, config.getZmqThreads());
+ }
+
+ @Test
+ public void getZmqIpc() {
+ String[] args = {
+ "--zmq-ipc", "ipc://test"
+ };
+ IotaConfig config = ConfigFactory.createIotaConfig(false);
+ config.parseConfigFromArgs(args);
+ assertTrue("ZMQ IPC must be enabled", config.isZmqEnableIpc());
+ assertEquals("ZMQ ipc must be overridden", "ipc://test", config.getZmqIpc());
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/com/iota/iri/controllers/BundleViewModelTest.java b/src/test/java/com/iota/iri/controllers/BundleViewModelTest.java
index f50f09583b..eeb99aa519 100644
--- a/src/test/java/com/iota/iri/controllers/BundleViewModelTest.java
+++ b/src/test/java/com/iota/iri/controllers/BundleViewModelTest.java
@@ -13,7 +13,7 @@
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionTrits;
+import static com.iota.iri.TransactionTestUtils.getTransactionTrits;
public class BundleViewModelTest {
private static final TemporaryFolder dbFolder = new TemporaryFolder();
@@ -71,7 +71,7 @@ public void getTail() throws Exception {
@Test
public void firstShouldFindTx() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
diff --git a/src/test/java/com/iota/iri/controllers/TipsViewModelTest.java b/src/test/java/com/iota/iri/controllers/TipsViewModelTest.java
index 0be38f4b5d..b5420df844 100644
--- a/src/test/java/com/iota/iri/controllers/TipsViewModelTest.java
+++ b/src/test/java/com/iota/iri/controllers/TipsViewModelTest.java
@@ -8,7 +8,7 @@
import java.util.concurrent.ExecutionException;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionHash;
+import static com.iota.iri.TransactionTestUtils.getTransactionHash;
import static org.junit.Assert.*;
@@ -79,7 +79,7 @@ public void nonsolidCapacityLimited() throws ExecutionException, InterruptedExce
int capacity = TipsViewModel.MAX_TIPS;
//fill tips list
for (int i = 0; i < capacity * 2 ; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
tipsVM.addTipHash(hash);
}
//check that limit wasn't breached
@@ -92,7 +92,7 @@ public void solidCapacityLimited() throws ExecutionException, InterruptedExcepti
int capacity = TipsViewModel.MAX_TIPS;
//fill tips list
for (int i = 0; i < capacity * 2 ; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
tipsVM.addTipHash(hash);
tipsVM.setSolid(hash);
}
@@ -106,7 +106,7 @@ public void totalCapacityLimited() throws ExecutionException, InterruptedExcepti
int capacity = TipsViewModel.MAX_TIPS;
//fill tips list
for (int i = 0; i <= capacity * 4; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
tipsVM.addTipHash(hash);
if (i % 2 == 1) {
tipsVM.setSolid(hash);
diff --git a/src/test/java/com/iota/iri/controllers/TransactionViewModelTest.java b/src/test/java/com/iota/iri/controllers/TransactionViewModelTest.java
index 4d059f1201..720316e842 100644
--- a/src/test/java/com/iota/iri/controllers/TransactionViewModelTest.java
+++ b/src/test/java/com/iota/iri/controllers/TransactionViewModelTest.java
@@ -23,9 +23,9 @@
import java.util.Random;
import java.util.Set;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionTrits;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionHash;
-import static com.iota.iri.TransactionTestUtils.getTransactionWithTrunkAndBranch;
+import static com.iota.iri.TransactionTestUtils.getTransactionTrits;
+import static com.iota.iri.TransactionTestUtils.getTransactionHash;
+import static com.iota.iri.TransactionTestUtils.getTransactionTritsWithTrunkAndBranch;
import static org.junit.Assert.*;
@@ -77,17 +77,17 @@ public void getApprovers() throws Exception {
TransactionViewModel transactionViewModel, otherTxVM, trunkTx, branchTx;
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
trunkTx = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
branchTx = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
- byte[] childTx = getRandomTransactionTrits();
+ byte[] childTx = getTransactionTrits();
System.arraycopy(trunkTx.getHash().trits(), 0, childTx, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_SIZE);
System.arraycopy(branchTx.getHash().trits(), 0, childTx, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_SIZE);
transactionViewModel = new TransactionViewModel(childTx, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, childTx));
- childTx = getRandomTransactionTrits();
+ childTx = getTransactionTrits();
System.arraycopy(trunkTx.getHash().trits(), 0, childTx, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_SIZE);
System.arraycopy(branchTx.getHash().trits(), 0, childTx, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_SIZE);
otherTxVM = new TransactionViewModel(childTx, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, childTx));
@@ -120,13 +120,13 @@ public void update() throws Exception {
public void trits() throws Exception {
byte[] blanks = new byte[13];
for(int i=0; i++ < 1000;) {
- byte[] trits = getRandomTransactionTrits(), searchTrits;
+ byte[] trits = getTransactionTrits(), searchTrits;
System.arraycopy(new byte[TransactionViewModel.VALUE_TRINARY_SIZE], 0, trits, TransactionViewModel.VALUE_TRINARY_OFFSET, TransactionViewModel.VALUE_TRINARY_SIZE);
Converter.copyTrits(seed.nextLong(), trits, TransactionViewModel.VALUE_TRINARY_OFFSET, TransactionViewModel.VALUE_USABLE_TRINARY_SIZE);
System.arraycopy(blanks, 0, trits, TransactionViewModel.TRUNK_TRANSACTION_TRINARY_OFFSET-blanks.length, blanks.length);
System.arraycopy(blanks, 0, trits, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET-blanks.length, blanks.length);
System.arraycopy(blanks, 0, trits, TransactionViewModel.BRANCH_TRANSACTION_TRINARY_OFFSET + TransactionViewModel.BRANCH_TRANSACTION_TRINARY_SIZE-blanks.length, blanks.length);
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, hash);
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
assertArrayEquals(transactionViewModel.trits(), TransactionViewModel.fromHash(tangle, transactionViewModel.getHash()).trits());
@@ -136,10 +136,10 @@ public void trits() throws Exception {
@Test
public void getBytes() throws Exception {
for(int i=0; i++ < 1000;) {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
System.arraycopy(new byte[TransactionViewModel.VALUE_TRINARY_SIZE], 0, trits, TransactionViewModel.VALUE_TRINARY_OFFSET, TransactionViewModel.VALUE_TRINARY_SIZE);
Converter.copyTrits(seed.nextLong(), trits, TransactionViewModel.VALUE_TRINARY_OFFSET, TransactionViewModel.VALUE_USABLE_TRINARY_SIZE);
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, hash);
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
assertArrayEquals(transactionViewModel.getBytes(), TransactionViewModel.fromHash(tangle, transactionViewModel.getHash()).getBytes());
@@ -295,13 +295,13 @@ public void getArrivalTime() throws Exception {
public void updateHeightShouldWork() throws Exception {
int count = 4;
TransactionViewModel[] transactionViewModels = new TransactionViewModel[count];
- Hash hash = getRandomTransactionHash();
- transactionViewModels[0] = new TransactionViewModel(getTransactionWithTrunkAndBranch(Hash.NULL_HASH,
+ Hash hash = getTransactionHash();
+ transactionViewModels[0] = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(Hash.NULL_HASH,
Hash.NULL_HASH), hash);
transactionViewModels[0].store(tangle, snapshotProvider.getInitialSnapshot());
for(int i = 0; ++i < count; ) {
- transactionViewModels[i] = new TransactionViewModel(getTransactionWithTrunkAndBranch(hash,
- Hash.NULL_HASH), hash = getRandomTransactionHash());
+ transactionViewModels[i] = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(hash,
+ Hash.NULL_HASH), hash = getTransactionHash());
transactionViewModels[i].store(tangle, snapshotProvider.getInitialSnapshot());
}
@@ -316,10 +316,10 @@ public void updateHeightShouldWork() throws Exception {
public void updateHeightPrefilledSlotShouldFail() throws Exception {
int count = 4;
TransactionViewModel[] transactionViewModels = new TransactionViewModel[count];
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
for(int i = 0; ++i < count; ) {
- transactionViewModels[i] = new TransactionViewModel(getTransactionWithTrunkAndBranch(hash,
- Hash.NULL_HASH), hash = getRandomTransactionHash());
+ transactionViewModels[i] = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(hash,
+ Hash.NULL_HASH), hash = getTransactionHash());
transactionViewModels[i].store(tangle, snapshotProvider.getInitialSnapshot());
}
@@ -332,7 +332,7 @@ public void updateHeightPrefilledSlotShouldFail() throws Exception {
@Test
public void findShouldBeSuccessful() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
Hash hash = transactionViewModel.getHash();
@@ -343,9 +343,9 @@ public void findShouldBeSuccessful() throws Exception {
@Test
public void findShouldReturnNull() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
- trits = getRandomTransactionTrits();
+ trits = getTransactionTrits();
TransactionViewModel transactionViewModelNoSave = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
Hash hash = transactionViewModelNoSave.getHash();
@@ -358,7 +358,7 @@ public void testManyTXInDB() throws Exception {
int i, j;
LinkedList hashes = new LinkedList<>();
Hash hash;
- hash = getRandomTransactionHash();
+ hash = getTransactionHash();
hashes.add(hash);
long start, diff, diffget;
long subSumDiff=0,maxdiff=0, sumdiff = 0;
@@ -366,13 +366,13 @@ public void testManyTXInDB() throws Exception {
int interval1 = 50;
int interval = interval1*10;
log.info("Starting Test. #TX: {}", TransactionViewModel.getNumberOfStoredTransactions(tangle));
- new TransactionViewModel(getTransactionWithTrunkAndBranch(Hash.NULL_HASH, Hash.NULL_HASH), hash).store(tangle, snapshotProvider.getInitialSnapshot());
+ new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(Hash.NULL_HASH, Hash.NULL_HASH), hash).store(tangle, snapshotProvider.getInitialSnapshot());
TransactionViewModel transactionViewModel;
boolean pop = false;
for (i = 0; i++ < max;) {
- hash = getRandomTransactionHash();
+ hash = getTransactionHash();
j = hashes.size();
- transactionViewModel = new TransactionViewModel(getTransactionWithTrunkAndBranch(hashes.get(seed.nextInt(j)), hashes.get(seed.nextInt(j))), hash);
+ transactionViewModel = new TransactionViewModel(getTransactionTritsWithTrunkAndBranch(hashes.get(seed.nextInt(j)), hashes.get(seed.nextInt(j))), hash);
start = System.nanoTime();
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
diff = System.nanoTime() - start;
@@ -408,7 +408,7 @@ public void testManyTXInDB() throws Exception {
@Test
public void firstShouldFindTx() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
TransactionViewModel transactionViewModel = new TransactionViewModel(trits, TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits));
transactionViewModel.store(tangle, snapshotProvider.getInitialSnapshot());
diff --git a/src/test/java/com/iota/iri/crypto/PearlDiverTest.java b/src/test/java/com/iota/iri/crypto/PearlDiverTest.java
index 68b2655b63..f68fabdfbb 100644
--- a/src/test/java/com/iota/iri/crypto/PearlDiverTest.java
+++ b/src/test/java/com/iota/iri/crypto/PearlDiverTest.java
@@ -55,7 +55,7 @@ public void testInvalidTritsLength() {
@Ignore("to test pearlDiver iteratively")
public void testNoRandomFail() {
for (int i = 0; i < 10000; i++) {
- byte[] trits = TransactionTestUtils.getRandomTransactionTrits();
+ byte[] trits = TransactionTestUtils.getTransactionTrits();
pearlDiver.search(trits, MIN_WEIGHT_MAGNITUDE, NUM_CORES);
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
for (int j = Hash.SIZE_IN_TRITS - 1; j > Hash.SIZE_IN_TRITS - MIN_WEIGHT_MAGNITUDE; j--) {
diff --git a/src/test/java/com/iota/iri/model/HashTest.java b/src/test/java/com/iota/iri/model/HashTest.java
index bdbb561916..17e854d64c 100644
--- a/src/test/java/com/iota/iri/model/HashTest.java
+++ b/src/test/java/com/iota/iri/model/HashTest.java
@@ -4,7 +4,7 @@
import com.iota.iri.crypto.SpongeFactory;
import com.iota.iri.utils.Converter;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionTrits;
+import static com.iota.iri.TransactionTestUtils.getTransactionTrits;
import org.junit.Assert;
import org.junit.Test;
@@ -14,7 +14,7 @@
public class HashTest {
@Test
public void calculate() throws Exception {
- Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getRandomTransactionTrits());
+ Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getTransactionTrits());
Assert.assertNotEquals(0, hash.hashCode());
Assert.assertNotEquals(null, hash.bytes());
Assert.assertNotEquals(null, hash.trits());
@@ -22,7 +22,7 @@ public void calculate() throws Exception {
@Test
public void calculate1() throws Exception {
- Hash hash = TransactionHash.calculate(getRandomTransactionTrits(), 0, 729, SpongeFactory.create(SpongeFactory.Mode.CURLP81));
+ Hash hash = TransactionHash.calculate(getTransactionTrits(), 0, 729, SpongeFactory.create(SpongeFactory.Mode.CURLP81));
Assert.assertNotEquals(null, hash.bytes());
Assert.assertNotEquals(0, hash.hashCode());
Assert.assertNotEquals(null, hash.trits());
@@ -30,7 +30,7 @@ public void calculate1() throws Exception {
@Test
public void calculate2() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
byte[] bytes = Converter.allocateBytesForTrits(trits.length);
Converter.bytes(trits, bytes);
Hash hash = TransactionHash.calculate(bytes, TransactionViewModel.TRINARY_SIZE, SpongeFactory.create(SpongeFactory.Mode.CURLP81));
@@ -47,23 +47,23 @@ public void trailingZeros() throws Exception {
@Test
public void trits() throws Exception {
- Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getRandomTransactionTrits());
+ Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getTransactionTrits());
Assert.assertFalse(Arrays.equals(new byte[Hash.SIZE_IN_TRITS], hash.trits()));
}
@Test
public void equals() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Hash hash1 = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Assert.assertTrue(hash.equals(hash1));
Assert.assertFalse(hash.equals(Hash.NULL_HASH));
- Assert.assertFalse(hash.equals(TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getRandomTransactionTrits())));
+ Assert.assertFalse(hash.equals(TransactionHash.calculate(SpongeFactory.Mode.CURLP81, getTransactionTrits())));
}
@Test
public void hashCodeTest() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Assert.assertNotEquals(hash.hashCode(), 0);
Assert.assertEquals(Hash.NULL_HASH.hashCode(), -240540129);
@@ -71,7 +71,7 @@ public void hashCodeTest() throws Exception {
@Test
public void toStringTest() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Assert.assertEquals(Hash.NULL_HASH.toString(), "999999999999999999999999999999999999999999999999999999999999999999999999999999999");
Assert.assertNotEquals(hash.toString(), "999999999999999999999999999999999999999999999999999999999999999999999999999999999");
@@ -81,7 +81,7 @@ public void toStringTest() throws Exception {
@Test
public void bytes() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Assert.assertTrue(Arrays.equals(new byte[Hash.SIZE_IN_BYTES], Hash.NULL_HASH.bytes()));
Assert.assertFalse(Arrays.equals(new byte[Hash.SIZE_IN_BYTES], hash.bytes()));
@@ -90,7 +90,7 @@ public void bytes() throws Exception {
@Test
public void compareTo() throws Exception {
- byte[] trits = getRandomTransactionTrits();
+ byte[] trits = getTransactionTrits();
Hash hash = TransactionHash.calculate(SpongeFactory.Mode.CURLP81, trits);
Assert.assertEquals(hash.compareTo(Hash.NULL_HASH), -Hash.NULL_HASH.compareTo(hash));
}
diff --git a/src/test/java/com/iota/iri/network/TransactionRequesterTest.java b/src/test/java/com/iota/iri/network/TransactionRequesterTest.java
index b4f02e88d3..72b909a9e6 100644
--- a/src/test/java/com/iota/iri/network/TransactionRequesterTest.java
+++ b/src/test/java/com/iota/iri/network/TransactionRequesterTest.java
@@ -5,12 +5,11 @@
import com.iota.iri.service.snapshot.SnapshotProvider;
import com.iota.iri.service.snapshot.impl.SnapshotProviderImpl;
import com.iota.iri.storage.Tangle;
-import com.iota.iri.zmq.MessageQ;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionHash;
+import static com.iota.iri.TransactionTestUtils.getTransactionHash;
import java.util.ArrayList;
import java.util.Arrays;
@@ -22,7 +21,6 @@
public class TransactionRequesterTest {
private static Tangle tangle = new Tangle();
private static SnapshotProvider snapshotProvider;
- private MessageQ mq;
@Before
public void setUp() throws Exception {
@@ -81,13 +79,13 @@ public void instance() throws Exception {
@Test
public void popEldestTransactionToRequest() throws Exception {
- TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider, mq);
+ TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider);
// Add some Txs to the pool and see if the method pops the eldest one
- Hash eldest = getRandomTransactionHash();
+ Hash eldest = getTransactionHash();
txReq.requestTransaction(eldest, false);
- txReq.requestTransaction(getRandomTransactionHash(), false);
- txReq.requestTransaction(getRandomTransactionHash(), false);
- txReq.requestTransaction(getRandomTransactionHash(), false);
+ txReq.requestTransaction(getTransactionHash(), false);
+ txReq.requestTransaction(getTransactionHash(), false);
+ txReq.requestTransaction(getTransactionHash(), false);
txReq.popEldestTransactionToRequest();
// Check that the transaction is there no more
@@ -98,18 +96,18 @@ public void popEldestTransactionToRequest() throws Exception {
public void transactionRequestedFreshness() throws Exception {
// Add some Txs to the pool and see if the method pops the eldest one
List eldest = new ArrayList(Arrays.asList(
- getRandomTransactionHash(),
- getRandomTransactionHash(),
- getRandomTransactionHash()
+ getTransactionHash(),
+ getTransactionHash(),
+ getTransactionHash()
));
- TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider, mq);
+ TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider);
int capacity = TransactionRequester.MAX_TX_REQ_QUEUE_SIZE;
//fill tips list
for (int i = 0; i < 3; i++) {
txReq.requestTransaction(eldest.get(i), false);
}
for (int i = 0; i < capacity; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
txReq.requestTransaction(hash,false);
}
@@ -123,11 +121,11 @@ public void transactionRequestedFreshness() throws Exception {
@Test
public void nonMilestoneCapacityLimited() throws Exception {
- TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider, mq);
+ TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider);
int capacity = TransactionRequester.MAX_TX_REQ_QUEUE_SIZE;
//fill tips list
for (int i = 0; i < capacity * 2 ; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
txReq.requestTransaction(hash,false);
}
//check that limit wasn't breached
@@ -136,11 +134,11 @@ public void nonMilestoneCapacityLimited() throws Exception {
@Test
public void milestoneCapacityNotLimited() throws Exception {
- TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider, mq);
+ TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider);
int capacity = TransactionRequester.MAX_TX_REQ_QUEUE_SIZE;
//fill tips list
for (int i = 0; i < capacity * 2 ; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
txReq.requestTransaction(hash,true);
}
//check that limit was surpassed
@@ -149,11 +147,11 @@ public void milestoneCapacityNotLimited() throws Exception {
@Test
public void mixedCapacityLimited() throws Exception {
- TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider, mq);
+ TransactionRequester txReq = new TransactionRequester(tangle, snapshotProvider);
int capacity = TransactionRequester.MAX_TX_REQ_QUEUE_SIZE;
//fill tips list
for (int i = 0; i < capacity * 4 ; i++) {
- Hash hash = getRandomTransactionHash();
+ Hash hash = getTransactionHash();
txReq.requestTransaction(hash, (i % 2 == 1));
}
diff --git a/src/test/java/com/iota/iri/network/impl/TransactionRequesterWorkerImplTest.java b/src/test/java/com/iota/iri/network/impl/TransactionRequesterWorkerImplTest.java
index 91060e854b..5bde327817 100644
--- a/src/test/java/com/iota/iri/network/impl/TransactionRequesterWorkerImplTest.java
+++ b/src/test/java/com/iota/iri/network/impl/TransactionRequesterWorkerImplTest.java
@@ -20,15 +20,13 @@
import com.iota.iri.model.persistables.Transaction;
import com.iota.iri.network.Node;
import com.iota.iri.network.TransactionRequester;
-import com.iota.iri.network.impl.TransactionRequesterWorkerImpl;
import com.iota.iri.service.snapshot.SnapshotProvider;
import com.iota.iri.storage.Tangle;
-import com.iota.iri.zmq.MessageQ;
-import static com.iota.iri.TransactionTestUtils.getRandomTransaction;
+import static com.iota.iri.TransactionTestUtils.getTransaction;
import static com.iota.iri.TransactionTestUtils.get9Transaction;
import static com.iota.iri.TransactionTestUtils.buildTransaction;
-import static com.iota.iri.TransactionTestUtils.getRandomTransactionHash;
+import static com.iota.iri.TransactionTestUtils.getTransactionHash;
import static org.mockito.Mockito.when;
@@ -36,13 +34,13 @@ public class TransactionRequesterWorkerImplTest {
//Good
private static final TransactionViewModel TVMRandomNull = new TransactionViewModel(
- getRandomTransaction(), Hash.NULL_HASH);
+ getTransaction(), Hash.NULL_HASH);
private static final TransactionViewModel TVMRandomNotNull = new TransactionViewModel(
- getRandomTransaction(), getRandomTransactionHash());
+ getTransaction(), getTransactionHash());
private static final TransactionViewModel TVMAll9Null = new TransactionViewModel(
get9Transaction(), Hash.NULL_HASH);
private static final TransactionViewModel TVMAll9NotNull = new TransactionViewModel(
- get9Transaction(), getRandomTransactionHash());
+ get9Transaction(), getTransactionHash());
//Bad
private static final TransactionViewModel TVMNullNull = new TransactionViewModel((Transaction)null, Hash.NULL_HASH);
@@ -53,9 +51,6 @@ public class TransactionRequesterWorkerImplTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private static SnapshotProvider snapshotProvider;
- @Mock
- private static MessageQ messageQ;
-
private static TransactionRequester requester;
private static TransactionRequesterWorkerImpl worker;
@@ -70,7 +65,7 @@ public class TransactionRequesterWorkerImplTest {
@Before
public void before() {
- requester = new TransactionRequester(tangle, snapshotProvider, messageQ);
+ requester = new TransactionRequester(tangle, snapshotProvider);
worker = new TransactionRequesterWorkerImpl();
worker.init(tangle, requester, tipsVM, node);
@@ -146,7 +141,7 @@ private void fillRequester() throws Exception {
}
private void addRequest() throws Exception {
- Hash randomHash = getRandomTransactionHash();
+ Hash randomHash = getTransactionHash();
TangleMockUtils.mockTransaction(tangle, randomHash);
requester.requestTransaction(randomHash, false);
}
diff --git a/src/test/java/com/iota/iri/service/APIIntegrationTests.java b/src/test/java/com/iota/iri/service/APIIntegrationTests.java
index 73152876a8..a3b90e061b 100644
--- a/src/test/java/com/iota/iri/service/APIIntegrationTests.java
+++ b/src/test/java/com/iota/iri/service/APIIntegrationTests.java
@@ -10,6 +10,7 @@
import com.iota.iri.controllers.TransactionViewModel;
import com.iota.iri.crypto.SpongeFactory;
import com.iota.iri.model.TransactionHash;
+import com.iota.iri.service.restserver.resteasy.RestEasy;
import com.iota.iri.utils.Converter;
import com.jayway.restassured.RestAssured;
import com.jayway.restassured.builder.ResponseSpecBuilder;
@@ -83,20 +84,24 @@ public static void setUp() throws Exception {
logFolder.create();
configuration = ConfigFactory.createIotaConfig(true);
- String[] args = {"-p", portStr, "--testnet", "--db-path", dbFolder.getRoot().getAbsolutePath(), "--db-log-path",
+ String[] args = {"-p", portStr, "--testnet", "true", "--db-path", dbFolder.getRoot().getAbsolutePath(), "--db-log-path",
logFolder.getRoot().getAbsolutePath(), "--mwm", "1"};
configuration.parseConfigFromArgs(args);
//create node
iota = new Iota(configuration);
ixi = new IXI(iota);
- api = new API(iota, ixi);
+ api = new API(iota.configuration, ixi, iota.transactionRequester,
+ iota.spentAddressesService, iota.tangle, iota.bundleValidator,
+ iota.snapshotProvider, iota.ledgerService, iota.node, iota.tipsSelector,
+ iota.tipsViewModel, iota.transactionValidator,
+ iota.latestMilestoneTracker);
//init
try {
iota.init();
iota.snapshotProvider.getInitialSnapshot().setTimestamp(0);
- api.init();
+ api.init(new RestEasy(configuration));
ixi.init(IXIConfig.IXI_DIR);
} catch (final Exception e) {
log.error("Exception during IOTA node initialisation: ", e);
diff --git a/src/test/java/com/iota/iri/service/ApiCallTest.java b/src/test/java/com/iota/iri/service/ApiCallTest.java
new file mode 100644
index 0000000000..3d00328542
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/ApiCallTest.java
@@ -0,0 +1,28 @@
+package com.iota.iri.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import com.iota.iri.conf.IotaConfig;
+
+public class ApiCallTest {
+
+ private API api;
+
+ @Before
+ public void setUp() {
+ IotaConfig configuration = Mockito.mock(IotaConfig.class);
+ api = new API(configuration, null, null, null, null, null, null, null, null, null, null, null, null);
+ }
+
+ @Test
+ public void apiHasAllEnums() {
+ for (ApiCommand c : ApiCommand.values()) {
+ if (!api.commandRoute.containsKey(c)) {
+ Assert.fail("Api should contain all enum values");
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/NodeIntegrationTests.java b/src/test/java/com/iota/iri/service/NodeIntegrationTests.java
index 47c93ad2c2..04b0d48051 100644
--- a/src/test/java/com/iota/iri/service/NodeIntegrationTests.java
+++ b/src/test/java/com/iota/iri/service/NodeIntegrationTests.java
@@ -12,6 +12,7 @@
import com.iota.iri.model.Hash;
import com.iota.iri.model.HashFactory;
import com.iota.iri.network.Node;
+import com.iota.iri.service.restserver.resteasy.RestEasy;
import com.iota.iri.utils.Converter;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.After;
@@ -52,8 +53,14 @@ public void testGetsSolid() throws Exception {
iotaNodes[i] = newNode(i, folders[i*2], folders[i*2+1]);
ixi[i] = new IXI(iotaNodes[i]);
ixi[i].init(IXIConfig.IXI_DIR);
- api[i] = new API(iotaNodes[i], ixi[i]);
- api[i].init();
+
+ api[i] = new API(iotaNodes[i].configuration, ixi[i], iotaNodes[i].transactionRequester,
+ iotaNodes[i].spentAddressesService, iotaNodes[i].tangle, iotaNodes[i].bundleValidator,
+ iotaNodes[i].snapshotProvider, iotaNodes[i].ledgerService, iotaNodes[i].node,
+ iotaNodes[i].tipsSelector, iotaNodes[i].tipsViewModel, iotaNodes[i].transactionValidator,
+ iotaNodes[i].latestMilestoneTracker);
+
+ api[i].init(new RestEasy(iotaNodes[i].configuration));
}
Node.uri("udp://localhost:14701").ifPresent(uri -> iotaNodes[0].node.addNeighbor(iotaNodes[0].node.newNeighbor(uri, true)));
//Node.uri("udp://localhost:14700").ifPresent(uri -> iotaNodes[1].node.addNeighbor(iotaNodes[1].node.newNeighbor(uri, true)));
diff --git a/src/test/java/com/iota/iri/service/restserver/RestEasyTest.java b/src/test/java/com/iota/iri/service/restserver/RestEasyTest.java
new file mode 100644
index 0000000000..f62f9f05d7
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/restserver/RestEasyTest.java
@@ -0,0 +1,135 @@
+package com.iota.iri.service.restserver;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.net.InetAddress;
+import java.util.Base64;
+
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.jboss.resteasy.test.TestPortProvider;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import com.iota.iri.conf.APIConfig;
+import com.iota.iri.service.dto.ErrorResponse;
+import com.iota.iri.service.dto.GetNodeInfoResponse;
+import com.iota.iri.service.restserver.resteasy.RestEasy;
+
+public class RestEasyTest {
+
+ private static final String USER_PASS = "user:pass";
+
+ @Rule
+ public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+ @Mock
+ private APIConfig apiconfig;
+
+
+ private RestEasy server;
+
+ @Before
+ public void setUp() {
+ Mockito.when(apiconfig.getPort()).thenReturn(TestPortProvider.getPort());
+ Mockito.when(apiconfig.getApiHost()).thenReturn(TestPortProvider.getHost());
+ Mockito.when(apiconfig.getMaxBodyLength()).thenReturn(Integer.MAX_VALUE);
+ }
+
+ @After
+ public void tearDown() {
+ this.server.stop();
+ }
+
+ @Test
+ public void nodeInfoMissingApiVersion() {
+ this.server = new RestEasy(apiconfig);
+ this.server.init((String param, InetAddress address) -> {
+ return GetNodeInfoResponse.createEmptyResponse();
+ });
+ this.server.start();
+
+ Client client = ClientBuilder.newClient();
+ String jsonString = "{\"command\": \"getNodeInfo\"}";
+ Response val = client.target(TestPortProvider.generateURL("/"))
+ .request()
+ .post(Entity.entity(jsonString, MediaType.APPLICATION_JSON));
+ ErrorResponse response = val.readEntity(ErrorResponse.class);
+ assertEquals("API version should be required in the header", "Invalid API Version", response.getError());
+ }
+
+ @Test
+ public void nodeInfoValid() {
+ this.server = new RestEasy(apiconfig);
+ this.server.init((String param, InetAddress address) -> {
+ return GetNodeInfoResponse.createEmptyResponse();
+ });
+ this.server.start();
+
+ Client client = ClientBuilder.newClient();
+ String jsonString = "{\"command\": \"getNodeInfo\"}";
+ Response val = client.target(TestPortProvider.generateURL("/"))
+ .request()
+ .header("X-IOTA-API-Version", "1")
+ .post(Entity.entity(jsonString, MediaType.APPLICATION_JSON));
+
+ GetNodeInfoResponse response = val.readEntity(GetNodeInfoResponse.class);
+ assertNotNull("Response should not be parseable as a GetNodeInfoResponse", response);
+ }
+
+ @Test
+ public void notAllowed() {
+ Mockito.when(apiconfig.getRemoteAuth()).thenReturn(USER_PASS);
+
+ this.server = new RestEasy(apiconfig);
+ this.server.init((String param, InetAddress address) -> {
+ return GetNodeInfoResponse.createEmptyResponse();
+ });
+ this.server.start();
+
+ Client client = ClientBuilder.newClient();
+ String jsonString = "{\"command\": \"getNodeInfo\"}";
+ Response val = client.target(TestPortProvider.generateURL("/"))
+ .request()
+ .header("X-IOTA-API-Version", "1")
+ .post(Entity.entity(jsonString, MediaType.APPLICATION_JSON));
+
+ assertEquals("Request should be denied due to lack of authentication",
+ Response.Status.UNAUTHORIZED, val.getStatusInfo());
+ }
+
+ @Test
+ public void allowed() {
+ Mockito.when(apiconfig.getRemoteAuth()).thenReturn(USER_PASS);
+
+ this.server = new RestEasy(apiconfig);
+ this.server.init((String param, InetAddress address) -> {
+ return GetNodeInfoResponse.createEmptyResponse();
+ });
+ this.server.start();
+
+ Client client = ClientBuilder.newClient();
+ String jsonString = "{\"command\": \"getNodeInfo\"}";
+
+ String encoded = Base64.getEncoder().encodeToString(USER_PASS.getBytes());
+
+ Response val = client.target(TestPortProvider.generateURL("/"))
+ .request()
+ .header("X-IOTA-API-Version", "1")
+ .header("Authorization", "Basic " + encoded)
+ .post(Entity.entity(jsonString, MediaType.APPLICATION_JSON));
+
+ assertEquals("Request should be accepted as we authenticated", Response.Status.OK, val.getStatusInfo());
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImplTest.java
new file mode 100644
index 0000000000..b1dd52bbb5
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/LocalSnapshotManagerImplTest.java
@@ -0,0 +1,149 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.any;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import com.iota.iri.conf.SnapshotConfig;
+import com.iota.iri.service.milestone.LatestMilestoneTracker;
+import com.iota.iri.service.snapshot.SnapshotException;
+import com.iota.iri.service.snapshot.SnapshotProvider;
+import com.iota.iri.service.snapshot.SnapshotService;
+import com.iota.iri.service.transactionpruning.TransactionPruner;
+import com.iota.iri.utils.thread.ThreadUtils;
+
+public class LocalSnapshotManagerImplTest {
+
+ private static final int BUFFER = LocalSnapshotManagerImpl.LOCAL_SNAPSHOT_SYNC_BUFFER;
+
+ private static final int DELAY_SYNC = 5;
+ private static final int DELAY_UNSYNC = 1;
+ private static final int SNAPSHOT_DEPTH = 5;
+
+ @Rule
+ public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+ @Mock
+ private static SnapshotConfig config;
+
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ SnapshotProvider snapshotProvider;
+
+ @Mock
+ SnapshotService snapshotService;
+
+ @Mock
+ TransactionPruner transactionPruner;
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ LatestMilestoneTracker milestoneTracker;
+
+ private LocalSnapshotManagerImpl lsManager;
+
+ @Before
+ public void setUp() throws Exception {
+ this.lsManager = new LocalSnapshotManagerImpl();
+
+ lsManager.init(snapshotProvider, snapshotService, transactionPruner, config);
+ when(snapshotProvider.getLatestSnapshot().getIndex()).thenReturn(-5, -1, 10, 998, 999, 1999, 2000);
+
+ when(config.getLocalSnapshotsIntervalSynced()).thenReturn(DELAY_SYNC);
+ when(config.getLocalSnapshotsIntervalUnsynced()).thenReturn(DELAY_UNSYNC);
+ when(config.getLocalSnapshotsDepth()).thenReturn(SNAPSHOT_DEPTH);
+ }
+
+ @After
+ public void tearDown() {
+ lsManager.shutdown();
+ }
+
+ @Test
+ public synchronized void takeLocalSnapshot() throws SnapshotException {
+ // Always return true
+ when(milestoneTracker.isInitialScanComplete()).thenReturn(true);
+
+ // When we call it, we are in sync
+ when(milestoneTracker.getLatestMilestoneIndex()).thenReturn(-5);
+
+ // We are more then the depth ahead
+ when(snapshotProvider.getLatestSnapshot().getIndex()).thenReturn(100);
+ when(snapshotProvider.getInitialSnapshot().getIndex()).thenReturn(100 - SNAPSHOT_DEPTH - DELAY_SYNC - 1);
+
+ // Run in separate thread to allow us to time-out
+ Thread t = new Thread(() -> lsManager.monitorThread(milestoneTracker));
+
+ t.start();
+ // We should finish directly, margin for slower computers
+ ThreadUtils.sleep(100);
+
+ // Cancel the thread
+ t.interrupt();
+
+ // Verify we took a snapshot
+ try {
+ verify(snapshotService, times(1)).takeLocalSnapshot(any(), any());
+ } catch (MockitoAssertionError e) {
+ throw new MockitoAssertionError("A snapshot should have been taken when we are below SNAPSHOT_DEPTH");
+ }
+ }
+
+ @Test
+ public void isInSyncTestScanIncomplete() {
+ when(milestoneTracker.isInitialScanComplete()).thenReturn(false);
+
+ assertFalse("We should be out of sync when he havent finished initial scans", lsManager.isInSync(milestoneTracker));
+ }
+
+ @Test
+ public void isInSyncTestScanComplete() {
+ // Always return true
+ when(milestoneTracker.isInitialScanComplete()).thenReturn(true);
+
+ // We don't really support -1 indexes, but if this breaks, it is a good indication to be careful going further
+ when(milestoneTracker.getLatestMilestoneIndex()).thenReturn(-1, 5, 10, 998 + BUFFER - 1, 2000);
+
+ // snapshotProvider & milestoneTracker
+ // -5 & -1 -> not in sync
+ assertFalse("Previous out of sync and not equal index should not be in sync", lsManager.isInSync(milestoneTracker));
+
+ // -1 and 5 -> not in sync
+ assertFalse("Previous out of sync and not equal index should not be in sync", lsManager.isInSync(milestoneTracker));
+
+ // 10 and 10 -> in sync
+ assertTrue("Equal index should be in sync", lsManager.isInSync(milestoneTracker));
+
+ // 998 and 1002 -> in sync since sync gap = 5
+ assertTrue("Index difference less than the buffer still should be in sync", lsManager.isInSync(milestoneTracker));
+
+ // 999 and 2000 -> out of sync again, bigger gap than 5
+ assertFalse("Index difference more than the buffer should be out of sync again ", lsManager.isInSync(milestoneTracker));
+
+ // 1999 and 2000 -> out of sync still
+ assertFalse("Previous out of sync and not equal index should not be in sync", lsManager.isInSync(milestoneTracker));
+
+ // 2000 and 2000 -> in sync again
+ assertTrue("Equal index should be in sync", lsManager.isInSync(milestoneTracker));
+ }
+
+ @Test
+ public void getDelayTest() {
+ assertEquals("Out of sync should return the config value at getLocalSnapshotsIntervalUnsynced",
+ DELAY_UNSYNC, lsManager.getSnapshotInterval(false));
+
+ assertEquals("In sync should return the config value at getLocalSnapshotsIntervalSynced",
+ DELAY_SYNC, lsManager.getSnapshotInterval(true));
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotImplTest.java
new file mode 100644
index 0000000000..2ac294fa06
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotImplTest.java
@@ -0,0 +1,68 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+
+import java.util.HashMap;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.iota.iri.TransactionTestUtils;
+import com.iota.iri.model.Hash;
+import com.iota.iri.service.snapshot.Snapshot;
+import com.iota.iri.service.snapshot.SnapshotMetaData;
+import com.iota.iri.service.snapshot.SnapshotState;
+
+public class SnapshotImplTest {
+
+ private static SnapshotState state;
+
+ private static SnapshotMetaData metaData;
+
+ @Before
+ public void setUp() throws Exception {
+ state = new SnapshotStateImpl(new HashMap<>());
+ metaData = new SnapshotMetaDataImpl(Hash.NULL_HASH, 1, 1l, new HashMap<>(), new HashMap<>());
+ }
+
+ @Test
+ public void skippedMilestoneTest() {
+ Snapshot snapshot = new SnapshotImpl(state, metaData);
+ assertTrue("Not previously seen milestone should be accepted", snapshot.addSkippedMilestone(1));
+
+ assertFalse("Previously seen milestone should not be accepted", snapshot.addSkippedMilestone(1));
+ assertTrue("Skipped milestone should be removed correctly", snapshot.removeSkippedMilestone(1));
+ assertFalse("Not skipped milestone should fail to get removed", snapshot.removeSkippedMilestone(1));
+ }
+
+ @Test
+ public void updateTest() {
+ Snapshot snapshot = new SnapshotImpl(state, metaData);
+ snapshot.setIndex(0);
+ snapshot.setHash(Hash.NULL_HASH);
+ snapshot.setInitialTimestamp(1l);
+
+ Snapshot newSnapshot = snapshot.clone();
+ newSnapshot.setIndex(1);
+ snapshot.setHash(TransactionTestUtils.getTransactionHash());
+ snapshot.setInitialTimestamp(5l);
+
+ assertNotEquals("Modified snapshot clone should not be equal to its original", snapshot, newSnapshot);
+ snapshot.update(newSnapshot);
+ assertEquals("Updating a snapshot with another snapshot should make them equal", snapshot, newSnapshot);
+ }
+
+ @Test
+ public void cloneTest() {
+ Snapshot oldSnapshot = new SnapshotImpl(state, metaData);
+ Snapshot newSnapshot = oldSnapshot.clone();
+
+ assertEquals("A clone of a snapshot is equal to its original", oldSnapshot, newSnapshot);
+
+ oldSnapshot.addSkippedMilestone(1);
+
+ // Clone shouldnt have the skipped milestone
+ assertFalse("Adding a value to a clone should be reflected on the original", newSnapshot.removeSkippedMilestone(1));
+ assertNotEquals("A clone should not be equal to its original after modification", oldSnapshot, newSnapshot);
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMetaDataImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMetaDataImplTest.java
new file mode 100644
index 0000000000..7e41c4696b
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMetaDataImplTest.java
@@ -0,0 +1,124 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.iota.iri.TransactionTestUtils;
+import com.iota.iri.conf.BaseIotaConfig;
+import com.iota.iri.model.Hash;
+import com.iota.iri.service.snapshot.SnapshotMetaData;
+
+public class SnapshotMetaDataImplTest {
+
+ private static final Hash A = TransactionTestUtils.getTransactionHash();
+ private static final Hash B = TransactionTestUtils.getTransactionHash();
+ private static final Hash C = TransactionTestUtils.getTransactionHash();
+ private static final Hash D = TransactionTestUtils.getTransactionHash();
+
+ private static Map solidEntryPoints = new HashMap(){{
+ put(A, 1);
+ put(B, 2);
+ put(C, -1);
+ }};
+
+ private static Map seenMilestones = new HashMap(){{
+ put(A, 10);
+ put(B, 11);
+ put(C, 12);
+ put(D, 13);
+ }};
+
+ private SnapshotMetaDataImpl meta;
+
+ @Before
+ public void setUp() {
+ meta = new SnapshotMetaDataImpl(A,
+ BaseIotaConfig.Defaults.MILESTONE_START_INDEX,
+ BaseIotaConfig.Defaults.GLOBAL_SNAPSHOT_TIME,
+ solidEntryPoints,
+ seenMilestones);
+ }
+
+ @Test
+ public void initialIndexTest(){
+ assertEquals("Initial index should be equal to the one provided",
+ meta.getInitialIndex(), BaseIotaConfig.Defaults.MILESTONE_START_INDEX);
+ assertEquals("Current index should be equal to the initial index",
+ meta.getIndex(), BaseIotaConfig.Defaults.MILESTONE_START_INDEX);
+
+ meta.setIndex(BaseIotaConfig.Defaults.MILESTONE_START_INDEX + 1);
+ assertNotEquals("Initial index should not be the same as current index after setting",
+ meta.getInitialIndex(), meta.getIndex());
+ }
+
+ @Test
+ public void initialTimestampTest(){
+ assertEquals("Initial timestamp should be equal to the one provided",
+ meta.getInitialTimestamp(), BaseIotaConfig.Defaults.GLOBAL_SNAPSHOT_TIME);
+ assertEquals("Current timestamp should be equal to the initial timestamp",
+ meta.getTimestamp(), BaseIotaConfig.Defaults.GLOBAL_SNAPSHOT_TIME);
+
+ meta.setTimestamp(BaseIotaConfig.Defaults.GLOBAL_SNAPSHOT_TIME + 1);
+ assertNotEquals("Initial timestamp should not be the same as current timestamp after setting",
+ meta.getInitialTimestamp(), meta.getTimestamp());
+ }
+
+ @Test
+ public void hashTest(){
+ assertEquals("Initial hash should be equal to the one provided", meta.getInitialHash(), A);
+
+ assertEquals("Current hash should be equal to the initial hash", meta.getHash(), A);
+
+ meta.setHash(B);
+ assertNotEquals("Initial hash should not be the same as current hash after setting", meta.getInitialHash(), meta.getHash());
+ }
+
+ @Test
+ public void solidEntryPointsTest(){
+ assertTrue("We should have the entry point provided on start", meta.hasSolidEntryPoint(A));
+ assertTrue("We should have the entry point provided on start", meta.hasSolidEntryPoint(B));
+ assertTrue("We should have the entry point provided on start", meta.hasSolidEntryPoint(C));
+
+ assertEquals("Index from entry should be to the one set to the hash", 1, meta.getSolidEntryPointIndex(A));
+ assertEquals("Index from entry should be to the one set to the hash", 2, meta.getSolidEntryPointIndex(B));
+
+ // Test -1 to ensure, if we ever enforce this positive, something could break
+ // We don't really support -1 indexes, but if this breaks, it is a good indication to be careful going further
+ assertEquals("Index from entry should be to the one set to the hash", -1, meta.getSolidEntryPointIndex(C));
+
+ assertEquals("Solid entries amount should be the same as the ones provided", meta.getSolidEntryPoints().size(), solidEntryPoints.size());
+ assertEquals("Solid entries should be the same as the ones provided", meta.getSolidEntryPoints(), new HashMap<>(solidEntryPoints));
+
+ meta.setSolidEntryPoints(seenMilestones);
+ // Right now, the map is replaced, so none are 'new' or 'existing'.
+ assertEquals("Existing entrypoints should have a new index", 10, meta.getSolidEntryPointIndex(A));
+ assertEquals("Existing entrypoints should have a new index", 11, meta.getSolidEntryPointIndex(B));
+ assertEquals("Existing entrypoints should have a new index", 12, meta.getSolidEntryPointIndex(C));
+ assertEquals("New entry point added should exist and equal to the index provided", 13, meta.getSolidEntryPointIndex(D));
+ }
+
+ @Test
+ public void seenMilestonesTest(){
+ assertEquals("Seen milestones amount should be the same as the ones provided",
+ meta.getSeenMilestones().size(), seenMilestones.size());
+ assertEquals("Seen milestones should be the same as the ones provided",
+ meta.getSeenMilestones(), new HashMap<>(seenMilestones));
+ }
+
+ @Test
+ public void createTest(){
+ SnapshotMetaData newMetaData = new SnapshotMetaDataImpl(meta);
+ assertEquals("new SnapshotMetaData made from another should be equal", newMetaData, meta);
+
+ newMetaData = new SnapshotMetaDataImpl(Hash.NULL_HASH, 0, 0l, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
+ newMetaData.update(meta);
+ assertEquals("Updating a SnapshotMetaData with another should make them equal", newMetaData, meta);
+ }
+
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMockUtils.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMockUtils.java
index 8d17c1b902..ff7e642ba7 100644
--- a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMockUtils.java
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotMockUtils.java
@@ -20,20 +20,60 @@ public class SnapshotMockUtils {
//region [mockSnapshotProvider] ////////////////////////////////////////////////////////////////////////////////////
+ /**
+ * Properly imitates a snapshot provider by making a real initial and latest snapshot.
+ * The balance of this provider is made to let the DEFAULT_GENESIS_ADDRESS (Null hash) have the entire IOTA supply.
+ * Genesis timestamp set to {@value #DEFAULT_GENESIS_TIMESTAMP}.
+ * Initial snapshot hash set to DEFAULT_GENESIS_ADDRESS.
+ * Starting index is {@value #DEFAULT_MILESTONE_START_INDEX}
+ *
+ * @param snapshotProvider The provider we are mocking. Must be a Mockito Mocked object
+ * @return The supplied snapshotProvider object
+ */
public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotProvider) {
return mockSnapshotProvider(snapshotProvider, DEFAULT_MILESTONE_START_INDEX);
}
+ /**
+ * Properly imitates a snapshot provider by making a real initial and latest snapshot.
+ * The balance of this provider is made to let the DEFAULT_GENESIS_ADDRESS (Null hash) have the entire IOTA supply.
+ * Genesis timestamp set to {@value #DEFAULT_GENESIS_TIMESTAMP}.
+ * Initial snapshot hash set to DEFAULT_GENESIS_ADDRESS.
+ *
+ * @param snapshotProvider The provider we are mocking. Must be a Mockito Mocked object
+ * @param milestoneStartIndex The index we use for the genesis/initial snapshot
+ * @return The supplied snapshotProvider object
+ */
public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotProvider, int milestoneStartIndex) {
return mockSnapshotProvider(snapshotProvider, milestoneStartIndex, DEFAULT_GENESIS_HASH);
}
+ /**
+ * Properly imitates a snapshot provider by making a real initial and latest snapshot.
+ * The balance of this provider is made to let the DEFAULT_GENESIS_ADDRESS (Null hash) have the entire IOTA supply.
+ * Genesis timestamp set to {@value #DEFAULT_GENESIS_TIMESTAMP}
+ *
+ * @param snapshotProvider The provider we are mocking. Must be a Mockito Mocked object
+ * @param milestoneStartIndex The index we use for the genesis/initial snapshot
+ * @param genesisHash The Genesis hash
+ * @return The supplied snapshotProvider object
+ */
public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotProvider, int milestoneStartIndex,
Hash genesisHash) {
return mockSnapshotProvider(snapshotProvider, milestoneStartIndex, genesisHash, DEFAULT_GENESIS_TIMESTAMP);
}
+ /**
+ * Properly imitates a snapshot provider by making a real initial and latest snapshot.
+ * The balance of this provider is made to let the DEFAULT_GENESIS_ADDRESS (Null hash) have the entire IOTA supply.
+ *
+ * @param snapshotProvider The provider we are mocking. Must be a Mockito Mocked object
+ * @param milestoneStartIndex The index we use for the genesis/initial snapshot
+ * @param genesisHash The Genesis hash
+ * @param genesisTimestamp The timestamp of the initial snapshot creation
+ * @return The supplied snapshotProvider object
+ */
public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotProvider, int milestoneStartIndex,
Hash genesisHash, long genesisTimestamp) {
@@ -43,6 +83,16 @@ public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotPro
return mockSnapshotProvider(snapshotProvider, milestoneStartIndex, genesisHash, genesisTimestamp, balances);
}
+ /**
+ * Properly imitates a snapshot provider by making a real initial and latest snapshot
+ *
+ * @param snapshotProvider The provider we are mocking. Must be a Mockito Mocked object
+ * @param milestoneStartIndex The index we use for the genesis/initial snapshot
+ * @param genesisHash The Genesis hash
+ * @param genesisTimestamp The timestamp of the initial snapshot creation
+ * @param balances The balances to add to the provider
+ * @return The supplied snapshotProvider object
+ */
public static SnapshotProvider mockSnapshotProvider(SnapshotProvider snapshotProvider, int milestoneStartIndex,
Hash genesisHash, long genesisTimestamp, Map balances) {
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImplTest.java
new file mode 100644
index 0000000000..8e51f88648
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotProviderImplTest.java
@@ -0,0 +1,59 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import com.iota.iri.conf.ConfigFactory;
+import com.iota.iri.conf.IotaConfig;
+import com.iota.iri.model.Hash;
+import com.iota.iri.service.snapshot.SnapshotException;
+import com.iota.iri.service.spentaddresses.SpentAddressesException;
+
+public class SnapshotProviderImplTest {
+
+ private SnapshotProviderImpl provider;
+
+ private SnapshotImpl cachedBuildinSnapshot;
+
+ @Before
+ public void setUp(){
+ provider = new SnapshotProviderImpl();
+
+ // When running multiple tests, the static cached snapshot breaks this test
+ cachedBuildinSnapshot = SnapshotProviderImpl.builtinSnapshot;
+ SnapshotProviderImpl.builtinSnapshot = null;
+ }
+
+ @After
+ public void tearDown(){
+ provider.shutdown();
+
+ // Set back the cached snapshot for tests after us who might use it
+ SnapshotProviderImpl.builtinSnapshot = cachedBuildinSnapshot;
+ }
+
+ @Test
+ public void testGetLatestSnapshot() throws SnapshotException, SpentAddressesException {
+ IotaConfig iotaConfig = ConfigFactory.createIotaConfig(true);
+ provider.init(iotaConfig);
+
+ // If we run this on its own, it correctly takes the testnet milestone
+ // However, running it with all tests makes it load the last global snapshot contained in the jar
+ assertEquals("Initial snapshot index should be the same as the milestone start index",
+ iotaConfig.getMilestoneStartIndex(), provider.getInitialSnapshot().getIndex());
+
+ assertEquals("Initial snapshot timestamp should be the same as last snapshot time",
+ iotaConfig.getSnapshotTime(), provider.getInitialSnapshot().getInitialTimestamp());
+
+ assertEquals("Initial snapshot hash should be the genisis transaction",
+ Hash.NULL_HASH, provider.getInitialSnapshot().getHash());
+
+ assertEquals("Initial provider snapshot should be equal to the latest snapshot",
+ provider.getInitialSnapshot(), provider.getLatestSnapshot());
+
+ assertTrue("Initial snapshot should have a filled map of addresses", provider.getInitialSnapshot().getBalances().size() > 0);
+ assertTrue("Initial snapshot supply should be equal to all supply", provider.getInitialSnapshot().hasCorrectSupply());
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateDiffImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateDiffImplTest.java
new file mode 100644
index 0000000000..6b2726b99e
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateDiffImplTest.java
@@ -0,0 +1,49 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+import com.iota.iri.TransactionTestUtils;
+import com.iota.iri.model.Hash;
+
+public class SnapshotStateDiffImplTest {
+
+ private static final Hash A = TransactionTestUtils.getTransactionHash();
+ private static final Hash B = TransactionTestUtils.getTransactionHash();
+ private static final Hash C = TransactionTestUtils.getTransactionHash();
+
+ @Test
+ public void getBalanceChanges() {
+ SnapshotStateDiffImpl stateDiff = new SnapshotStateDiffImpl(Collections.EMPTY_MAP);
+ Map change = stateDiff.getBalanceChanges();
+ change.put(A, 1l);
+
+ assertNotEquals("Changes to the statediff balance changes shouldnt reflect on the original state",
+ stateDiff.getBalanceChanges().size(), change.size());
+ }
+
+ @Test
+ public void isConsistent() {
+ SnapshotStateDiffImpl stateDiff = new SnapshotStateDiffImpl(new HashMap(){{
+ put(A, 1l);
+ put(B, 5l);
+ put(C, -6l);
+ }});
+ assertTrue("Sum of diffs should be 0", stateDiff.isConsistent());
+
+ stateDiff = new SnapshotStateDiffImpl(Collections.EMPTY_MAP);
+ assertTrue("Empty diff should be consisntent as sum is 0", stateDiff.isConsistent());
+
+ stateDiff = new SnapshotStateDiffImpl(new HashMap(){{
+ put(A, 1l);
+ put(B, 5l);
+ }});
+
+ assertFalse("Diff sum not 0 shouldnt be consistent", stateDiff.isConsistent());
+ }
+}
diff --git a/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateImplTest.java b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateImplTest.java
new file mode 100644
index 0000000000..83f5bef544
--- /dev/null
+++ b/src/test/java/com/iota/iri/service/snapshot/impl/SnapshotStateImplTest.java
@@ -0,0 +1,135 @@
+package com.iota.iri.service.snapshot.impl;
+
+import static org.junit.Assert.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.iota.iri.TransactionTestUtils;
+import com.iota.iri.controllers.TransactionViewModel;
+import com.iota.iri.model.Hash;
+import com.iota.iri.service.snapshot.SnapshotException;
+import com.iota.iri.service.snapshot.SnapshotState;
+import com.iota.iri.service.snapshot.SnapshotStateDiff;
+
+public class SnapshotStateImplTest {
+
+ private static final Hash A = TransactionTestUtils.getTransactionHash();
+ private static final Hash B = TransactionTestUtils.getTransactionHash();
+
+ private static Map map = new HashMap(){{
+ put(Hash.NULL_HASH, TransactionViewModel.SUPPLY - 10);
+ put(A, 10l);
+ }};
+
+ private static Map inconsistentMap = new HashMap(){{
+ put(Hash.NULL_HASH, 5l);
+ put(A, -10l);
+ }};
+
+ private SnapshotStateImpl state;
+ private SnapshotStateImpl balanceState;
+
+ @Before
+ public void setUp() throws Exception {
+ state = new SnapshotStateImpl(new HashMap<>());
+ balanceState = new SnapshotStateImpl(map);
+ }
+
+ @Test
+ public void testGetBalance() {
+ assertNull("Unknown address should return null", balanceState.getBalance(null));
+
+ long balance = balanceState.getBalance(Hash.NULL_HASH);
+ assertEquals("Balance should be total - 10", TransactionViewModel.SUPPLY - 10l, balance);
+
+ balance = balanceState.getBalance(A);
+ assertEquals("Balance should be 10", 10l, balance);
+ }
+
+ @Test
+ public void testGetBalances() {
+ assertEquals("State should not have balances", new HashMap<>(), state.getBalances());
+ assertEquals("State should have the balances it was created with", map, balanceState.getBalances());
+ }
+
+ @Test
+ public void testIsConsistent() {
+ assertTrue("Empty balance should be consistent", state.isConsistent());
+ assertTrue("No negative balances should be consistent", balanceState.isConsistent());
+
+ SnapshotStateImpl inconsistentState = new SnapshotStateImpl(inconsistentMap);
+ assertFalse("Negative balances should not be consistent", inconsistentState.isConsistent());
+ }
+
+ @Test
+ public void testHasCorrectSupply() {
+ assertFalse("Empty state should not have correct supply", state.hasCorrectSupply());
+ assertTrue("State with total supply should have correct supply", balanceState.hasCorrectSupply());
+
+ SnapshotStateImpl inconsistentState = new SnapshotStateImpl(inconsistentMap);
+ assertFalse("Inconsistent state without full supply should be incorrect", inconsistentState.hasCorrectSupply());
+
+ Map map = new HashMap<>();
+ map.put(Hash.NULL_HASH, TransactionViewModel.SUPPLY - 10);
+ map.put(A, -10l);
+ map.put(B, 20l);
+ assertFalse("Inconsistent state with full supply should be correct", inconsistentState.hasCorrectSupply());
+ }
+
+ @Test
+ public void testUpdate() {
+ assertNotEquals("States with different balances should not be equal", state, balanceState);
+ state.update(balanceState);
+
+ assertEquals("Updating a state with another state should make them equal", state, balanceState);
+ }
+
+ @Test
+ public void testApplyStateDiff() throws SnapshotException {
+ Map