Ecosystem/haveno
Ecosystem/haveno
2
1
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2024-12-22 19:49:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

remove trade on error force closes and shuts down thread

Browse source
This commit is contained in:
woodser 2024-07-18 10:15:59 -04:00
parent 291622e452
commit 82d586ab78
2 changed files with 36 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/src/main/java/haveno/core/trade/Trade.java
View file

@ -1657,6 +1657,16 @@ public abstract class Trade implements Tradable, Model {
private void removeTradeOnError() { private void removeTradeOnError() {
log.warn("removeTradeOnError() trade={}, tradeId={}, state={}", getClass().getSimpleName(), getShortId(), getState()); log.warn("removeTradeOnError() trade={}, tradeId={}, state={}", getClass().getSimpleName(), getShortId(), getState());
// force close wallet in case stuck
forceCloseWallet();
// shut down trade thread
try {
ThreadUtils.shutDown(getId(), 1000l);
} catch (Exception e) {
log.warn("Error shutting down trade thread for {} {}: {}", getClass().getSimpleName(), getId(), e.getMessage());
}
// clear and shut down trade // clear and shut down trade
clearAndShutDown(); clearAndShutDown();

50
core/src/main/java/haveno/core/trade/TradeManager.java
View file

@ -284,23 +284,25 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void onDirectMessage(DecryptedMessageWithPubKey message, NodeAddress peer) { public void onDirectMessage(DecryptedMessageWithPubKey message, NodeAddress sender) {
NetworkEnvelope networkEnvelope = message.getNetworkEnvelope(); NetworkEnvelope networkEnvelope = message.getNetworkEnvelope();
if (!(networkEnvelope instanceof TradeMessage)) return; if (!(networkEnvelope instanceof TradeMessage)) return;
String tradeId = ((TradeMessage) networkEnvelope).getOfferId(); TradeMessage tradeMessage = (TradeMessage) networkEnvelope;
String tradeId = tradeMessage.getOfferId();
log.info("TradeManager received {} for tradeId={}, sender={}, uid={}", networkEnvelope.getClass().getSimpleName(), tradeId, sender, tradeMessage.getUid());
ThreadUtils.execute(() -> { ThreadUtils.execute(() -> {
if (networkEnvelope instanceof InitTradeRequest) { if (networkEnvelope instanceof InitTradeRequest) {
handleInitTradeRequest((InitTradeRequest) networkEnvelope, peer); handleInitTradeRequest((InitTradeRequest) networkEnvelope, sender);
} else if (networkEnvelope instanceof InitMultisigRequest) { } else if (networkEnvelope instanceof InitMultisigRequest) {
handleInitMultisigRequest((InitMultisigRequest) networkEnvelope, peer); handleInitMultisigRequest((InitMultisigRequest) networkEnvelope, sender);
} else if (networkEnvelope instanceof SignContractRequest) { } else if (networkEnvelope instanceof SignContractRequest) {
handleSignContractRequest((SignContractRequest) networkEnvelope, peer); handleSignContractRequest((SignContractRequest) networkEnvelope, sender);
} else if (networkEnvelope instanceof SignContractResponse) { } else if (networkEnvelope instanceof SignContractResponse) {
handleSignContractResponse((SignContractResponse) networkEnvelope, peer); handleSignContractResponse((SignContractResponse) networkEnvelope, sender);
} else if (networkEnvelope instanceof DepositRequest) { } else if (networkEnvelope instanceof DepositRequest) {
handleDepositRequest((DepositRequest) networkEnvelope, peer); handleDepositRequest((DepositRequest) networkEnvelope, sender);
} else if (networkEnvelope instanceof DepositResponse) { } else if (networkEnvelope instanceof DepositResponse) {
handleDepositResponse((DepositResponse) networkEnvelope, peer); handleDepositResponse((DepositResponse) networkEnvelope, sender);
} }
}, tradeId); }, tradeId);
} }
@ -538,7 +540,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
} }
private void handleInitTradeRequest(InitTradeRequest request, NodeAddress sender) { private void handleInitTradeRequest(InitTradeRequest request, NodeAddress sender) {
log.info("Received InitTradeRequest from {} with tradeId {} and uid {}", sender, request.getOfferId(), request.getUid()); log.info("TradeManager handling InitTradeRequest for tradeId={}, sender={}, uid={}", request.getOfferId(), sender, request.getUid());
try { try {
Validator.nonEmptyStringOf(request.getOfferId()); Validator.nonEmptyStringOf(request.getOfferId());
@ -734,8 +736,8 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
} }
} }
private void handleInitMultisigRequest(InitMultisigRequest request, NodeAddress peer) { private void handleInitMultisigRequest(InitMultisigRequest request, NodeAddress sender) {
log.info("Received {} for trade {} from {} with uid {}", request.getClass().getSimpleName(), request.getOfferId(), peer, request.getUid()); log.info("TradeManager handling InitMultisigRequest for tradeId={}, sender={}, uid={}", request.getOfferId(), sender, request.getUid());
try { try {
Validator.nonEmptyStringOf(request.getOfferId()); Validator.nonEmptyStringOf(request.getOfferId());
@ -750,11 +752,11 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
return; return;
} }
Trade trade = tradeOptional.get(); Trade trade = tradeOptional.get();
getTradeProtocol(trade).handleInitMultisigRequest(request, peer); getTradeProtocol(trade).handleInitMultisigRequest(request, sender);
} }
private void handleSignContractRequest(SignContractRequest request, NodeAddress peer) { private void handleSignContractRequest(SignContractRequest request, NodeAddress sender) {
log.info("Received {} for trade {} from {} with uid {}", request.getClass().getSimpleName(), request.getOfferId(), peer, request.getUid()); log.info("TradeManager handling SignContractRequest for tradeId={}, sender={}, uid={}", request.getOfferId(), sender, request.getUid());
try { try {
Validator.nonEmptyStringOf(request.getOfferId()); Validator.nonEmptyStringOf(request.getOfferId());
@ -769,11 +771,11 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
return; return;
} }
Trade trade = tradeOptional.get(); Trade trade = tradeOptional.get();
getTradeProtocol(trade).handleSignContractRequest(request, peer); getTradeProtocol(trade).handleSignContractRequest(request, sender);
} }
private void handleSignContractResponse(SignContractResponse request, NodeAddress peer) { private void handleSignContractResponse(SignContractResponse request, NodeAddress sender) {
log.info("Received {} for trade {} from {} with uid {}", request.getClass().getSimpleName(), request.getOfferId(), peer, request.getUid()); log.info("TradeManager handling SignContractResponse for tradeId={}, sender={}, uid={}", request.getOfferId(), sender, request.getUid());
try { try {
Validator.nonEmptyStringOf(request.getOfferId()); Validator.nonEmptyStringOf(request.getOfferId());
@ -788,11 +790,11 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
return; return;
} }
Trade trade = tradeOptional.get(); Trade trade = tradeOptional.get();
((TraderProtocol) getTradeProtocol(trade)).handleSignContractResponse(request, peer); ((TraderProtocol) getTradeProtocol(trade)).handleSignContractResponse(request, sender);
} }
private void handleDepositRequest(DepositRequest request, NodeAddress peer) { private void handleDepositRequest(DepositRequest request, NodeAddress sender) {
log.info("Received {} for trade {} from {} with uid {}", request.getClass().getSimpleName(), request.getOfferId(), peer, request.getUid()); log.info("TradeManager handling DepositRequest for tradeId={}, sender={}, uid={}", request.getOfferId(), sender, request.getUid());
try { try {
Validator.nonEmptyStringOf(request.getOfferId()); Validator.nonEmptyStringOf(request.getOfferId());
@ -807,11 +809,11 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
return; return;
} }
Trade trade = tradeOptional.get(); Trade trade = tradeOptional.get();
((ArbitratorProtocol) getTradeProtocol(trade)).handleDepositRequest(request, peer); ((ArbitratorProtocol) getTradeProtocol(trade)).handleDepositRequest(request, sender);
} }
private void handleDepositResponse(DepositResponse response, NodeAddress peer) { private void handleDepositResponse(DepositResponse response, NodeAddress sender) {
log.info("Received {} for trade {} from {} with uid {}", response.getClass().getSimpleName(), response.getOfferId(), peer, response.getUid()); log.info("TradeManager handling DepositResponse for tradeId={}, sender={}, uid={}", response.getOfferId(), sender, response.getUid());
try { try {
Validator.nonEmptyStringOf(response.getOfferId()); Validator.nonEmptyStringOf(response.getOfferId());
@ -829,7 +831,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
} }
} }
Trade trade = tradeOptional.get(); Trade trade = tradeOptional.get();
((TraderProtocol) getTradeProtocol(trade)).handleDepositResponse(response, peer); ((TraderProtocol) getTradeProtocol(trade)).handleDepositResponse(response, sender);
} }
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////