Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 23:56:30 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add timeout

Browse Source
This commit is contained in:
Manfred Karrer 2015-04-03 19:00:46 +02:00
parent d09fb97f8d
commit 76a4a7f2c3
9 changed files with 138 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesViewModel.java
View File

@ -64,6 +64,7 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
BUYER_COMPLETED,
MESSAGE_SENDING_FAILED,
TIMEOUT,
EXCEPTION
}
@ -301,6 +302,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case TIMEOUT:
viewState.set(ViewState.TIMEOUT);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
@ -343,6 +347,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case TIMEOUT:
viewState.set(ViewState.TIMEOUT);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
@ -388,6 +395,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case TIMEOUT:
viewState.set(ViewState.TIMEOUT);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
@ -424,6 +434,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case TIMEOUT:
viewState.set(ViewState.TIMEOUT);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;

7
core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferViewModel.java
View File

@ -283,7 +283,12 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
takeOfferRequested = false;
break;
case MESSAGE_SENDING_FAILED:
errorMessage.set("An error occurred when sending a message to the offerer. Maybe there are connection problems. " +
errorMessage.set("Sending a message to the offerer failed. Maybe there are connection problems. " +
"Please try later again." + msg);
takeOfferRequested = false;
break;
case TIMEOUT:
errorMessage.set("Timeout: We did not received a message from the offerer. Maybe there are connection problems. " +
"Please try later again." + msg);
takeOfferRequested = false;
break;

41
core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java
View File

@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.BuyerAsOffererTrade;
@ -51,21 +50,19 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*;
public class BuyerAsOffererProtocol implements TradeProtocol {
public class BuyerAsOffererProtocol extends TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererProtocol.class);
private MessageHandler messageHandler;
private final BuyerAsOffererTrade trade;
private final ProcessModel processModel;
private final BuyerAsOffererTrade buyerAsOffererTrade;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsOffererProtocol(BuyerAsOffererTrade trade) {
super(trade.getProcessModel());
log.debug("New OffererProtocol " + this);
this.trade = trade;
processModel = this.trade.getProcessModel();
this.buyerAsOffererTrade = trade;
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -76,6 +73,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
// Public methods
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
@ -87,14 +85,6 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
}
}
public void cleanup() {
log.debug("cleanup " + this);
if (messageHandler != null) {
processModel.getMessageService().removeMessageHandler(messageHandler);
messageHandler = null;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Incoming message handling
@ -109,7 +99,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
// to take the
// offer
// at the same time
boolean isOfferOpen = trade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
boolean isOfferOpen = buyerAsOffererTrade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override
@ -134,11 +124,11 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
private void handle(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(processModel.getId(), tradeMessage);
processModel.setTradeMessage(tradeMessage);
trade.setTradingPeer(taker);
buyerAsOffererTrade.setTradingPeer(taker);
trade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_RESERVED);
buyerAsOffererTrade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_RESERVED);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -152,7 +142,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -172,7 +162,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
// User clicked the "bank transfer started" button
public void onFiatPaymentStarted() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -191,7 +181,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done!
@ -215,7 +205,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(trade.getId())) {
if (tradeMessage.tradeId.equals(buyerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
}
@ -234,9 +224,4 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
}
}
}
private void handleTaskRunnerFault(String errorMessage) {
log.error(errorMessage);
cleanup();
}
}

30
core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java
View File

@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Trade;
@ -47,12 +46,10 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class BuyerAsTakerProtocol implements TradeProtocol {
public class BuyerAsTakerProtocol extends TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class);
private final BuyerAsTakerTrade trade;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
private final BuyerAsTakerTrade buyerAsTakerTrade;
///////////////////////////////////////////////////////////////////////////////////////////
@ -60,9 +57,9 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsTakerProtocol(BuyerAsTakerTrade trade) {
super(trade.getProcessModel());
log.debug("New SellerAsTakerProtocol " + this);
this.trade = trade;
processModel = trade.getProcessModel();
this.buyerAsTakerTrade = trade;
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -73,6 +70,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
// Public methods
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
@ -85,7 +83,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
}
public void takeAvailableOffer() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at takeAvailableOffer completed"),
this::handleTaskRunnerFault);
@ -98,10 +96,6 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
taskRunner.run();
}
public void cleanup() {
log.debug("cleanup " + this);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Incoming message handling
@ -110,7 +104,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -130,7 +124,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
// User clicked the "bank transfer started" button
public void onFiatPaymentStarted() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at onFiatPaymentStarted completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -149,7 +143,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done!
@ -187,10 +181,4 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
}
}
}
private void handleTaskRunnerFault(String errorMessage) {
log.error(errorMessage);
cleanup();
}
}

39
core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java
View File

@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.SellerAsOffererTrade;
@ -49,21 +48,20 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*;
public class SellerAsOffererProtocol implements TradeProtocol {
public class SellerAsOffererProtocol extends TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(SellerAsOffererProtocol.class);
private final MessageHandler messageHandler;
private final SellerAsOffererTrade trade;
private final ProcessModel processModel;
private final SellerAsOffererTrade sellerAsOffererTrade;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsOffererProtocol(SellerAsOffererTrade trade) {
super(trade.getProcessModel());
log.debug("New OffererProtocol " + this);
this.trade = trade;
processModel = this.trade.getProcessModel();
this.sellerAsOffererTrade = trade;
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -74,6 +72,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
// Public methods
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
@ -88,11 +87,6 @@ public class SellerAsOffererProtocol implements TradeProtocol {
}
}
public void cleanup() {
log.debug("cleanup " + this);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Incoming message handling
@ -110,7 +104,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
// to take the
// offer
// at the same time
boolean isOfferOpen = trade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
boolean isOfferOpen = sellerAsOffererTrade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@ -140,9 +134,9 @@ public class SellerAsOffererProtocol implements TradeProtocol {
private void handle(RequestPayDepositMessage tradeMessage, Peer sender) {
processModel.setTradeMessage(tradeMessage);
trade.setTradingPeer(sender);
sellerAsOffererTrade.setTradingPeer(sender);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
this::handleTaskRunnerFault);
@ -159,7 +153,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault);
@ -173,7 +167,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
this::handleTaskRunnerFault);
@ -188,9 +182,9 @@ public class SellerAsOffererProtocol implements TradeProtocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out
public void onFiatPaymentReceived() {
trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
sellerAsOffererTrade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed");
@ -217,7 +211,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(trade.getId())) {
if (tradeMessage.tradeId.equals(sellerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
}
@ -236,9 +230,4 @@ public class SellerAsOffererProtocol implements TradeProtocol {
}
}
}
private void handleTaskRunnerFault(String errorMessage) {
log.error(errorMessage);
cleanup();
}
}

42
core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java
View File

@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.Trade;
@ -49,12 +48,10 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class SellerAsTakerProtocol implements TradeProtocol {
public class SellerAsTakerProtocol extends TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(SellerAsTakerProtocol.class);
private final SellerAsTakerTrade trade;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
private final SellerAsTakerTrade sellerAsTakerTrade;
///////////////////////////////////////////////////////////////////////////////////////////
@ -62,9 +59,9 @@ public class SellerAsTakerProtocol implements TradeProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(SellerAsTakerTrade trade) {
super(trade.getProcessModel());
log.debug("New SellerAsTakerProtocol " + this);
this.trade = trade;
processModel = trade.getProcessModel();
this.sellerAsTakerTrade = trade;
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -75,6 +72,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
// Public methods
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
@ -90,8 +88,11 @@ public class SellerAsTakerProtocol implements TradeProtocol {
}
public void takeAvailableOffer() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
() -> log.debug("taskRunner at takeAvailableOffer completed"),
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> {
log.debug("taskRunner at takeAvailableOffer completed");
startTimeout();
},
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -102,20 +103,17 @@ public class SellerAsTakerProtocol implements TradeProtocol {
taskRunner.run();
}
public void cleanup() {
log.debug("cleanup " + this);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPayDepositMessage tradeMessage) {
log.debug("handle RequestPayDepositMessage");
stopTimeout();
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
this::handleTaskRunnerFault);
@ -132,7 +130,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault);
@ -146,7 +144,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
this::handleTaskRunnerFault);
@ -161,9 +159,9 @@ public class SellerAsTakerProtocol implements TradeProtocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out
public void onFiatPaymentReceived() {
trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
sellerAsTakerTrade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed");
@ -206,10 +204,4 @@ public class SellerAsTakerProtocol implements TradeProtocol {
}
}
}
private void handleTaskRunnerFault(String errorMessage) {
log.error(errorMessage);
cleanup();
}
}

67
core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java
View File

@ -18,9 +18,70 @@
package io.bitsquare.trade.protocol.trade;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.states.OffererTradeState;
import io.bitsquare.trade.states.TakerTradeState;
public interface TradeProtocol {
void cleanup();
import java.util.Timer;
import java.util.TimerTask;
void setMailboxMessage(MailboxMessage mailboxMessage);
import javafx.application.Platform;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(TradeProtocol.class);
protected final ProcessModel processModel;
protected MessageHandler messageHandler;
protected Timer timeoutTimer;
protected Trade trade;
public TradeProtocol(ProcessModel processModel) {
this.processModel = processModel;
}
public void cleanup() {
log.debug("cleanup " + this);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
abstract public void setMailboxMessage(MailboxMessage mailboxMessage);
protected void startTimeout() {
log.debug("startTimeout");
stopTimeout();
timeoutTimer = new Timer();
TimerTask task = new TimerTask() {
@Override
public void run() {
Platform.runLater(() -> {
log.debug("Timeout reached");
if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TIMEOUT);
else
trade.setProcessState(OffererTradeState.ProcessState.TIMEOUT);
});
}
};
timeoutTimer.schedule(task, 3000);
}
protected void stopTimeout() {
log.debug("stopTimeout");
if (timeoutTimer != null) {
timeoutTimer.cancel();
timeoutTimer = null;
}
}
protected void handleTaskRunnerFault(String errorMessage) {
log.error(errorMessage);
cleanup();
}
}

1
core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java
View File

@ -44,6 +44,7 @@ public class OffererTradeState {
PAYOUT_PUBLISHED_MSG_SENT,
MESSAGE_SENDING_FAILED,
TIMEOUT,
EXCEPTION
}
}

1
core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java
View File

@ -45,6 +45,7 @@ public class TakerTradeState {
PAYOUT_PUBLISHED_MSG_SENT,
MESSAGE_SENDING_FAILED,
TIMEOUT,
EXCEPTION
}
}