Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-07-28 09:24:15 -04:00
Code Issues Projects Releases Packages Wiki Activity

Renamed MailMessage to DirectMessage

Browse source
This commit is contained in:
Manfred Karrer 2016-01-27 01:02:56 +01:00
parent 602c503cea
commit 7b87c39ffd
33 changed files with 210 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

30
core/src/main/java/io/bitsquare/arbitration/Dispute.java
View file

@ -18,7 +18,7 @@
package io.bitsquare.arbitration;
import io.bitsquare.app.Version;
import io.bitsquare.arbitration.messages.DisputeMailMessage;
import io.bitsquare.arbitration.messages.DisputeDirectMessage;
import io.bitsquare.common.crypto.PubKeyRing;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.Contract;
@ -69,13 +69,13 @@ public class Dispute implements Serializable {
private final PubKeyRing arbitratorPubKeyRing;
private final boolean isSupportTicket;
private final List<DisputeMailMessage> disputeMailMessages = new ArrayList<>();
private final List<DisputeDirectMessage> disputeDirectMessages = new ArrayList<>();
private boolean isClosed;
private DisputeResult disputeResult;
transient private Storage<DisputeList<Dispute>> storage;
transient private ObservableList<DisputeMailMessage> disputeMailMessagesAsObservableList = FXCollections.observableArrayList(disputeMailMessages);
transient private ObservableList<DisputeDirectMessage> disputeDirectMessagesAsObservableList = FXCollections.observableArrayList(disputeDirectMessages);
transient private BooleanProperty isClosedProperty = new SimpleBooleanProperty(isClosed);
transient private ObjectProperty<DisputeResult> disputeResultProperty = new SimpleObjectProperty<>(disputeResult);
@ -126,7 +126,7 @@ public class Dispute implements Serializable {
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
try {
in.defaultReadObject();
disputeMailMessagesAsObservableList = FXCollections.observableArrayList(disputeMailMessages);
disputeDirectMessagesAsObservableList = FXCollections.observableArrayList(disputeDirectMessages);
disputeResultProperty = new SimpleObjectProperty<>(disputeResult);
isClosedProperty = new SimpleBooleanProperty(isClosed);
} catch (Throwable t) {
@ -134,13 +134,13 @@ public class Dispute implements Serializable {
}
}
public void addDisputeMessage(DisputeMailMessage disputeMailMessage) {
if (!disputeMailMessages.contains(disputeMailMessage)) {
disputeMailMessages.add(disputeMailMessage);
disputeMailMessagesAsObservableList.add(disputeMailMessage);
public void addDisputeMessage(DisputeDirectMessage disputeDirectMessage) {
if (!disputeDirectMessages.contains(disputeDirectMessage)) {
disputeDirectMessages.add(disputeDirectMessage);
disputeDirectMessagesAsObservableList.add(disputeDirectMessage);
storage.queueUpForSave();
} else {
log.error("disputeMailMessage already exists");
log.error("disputeDirectMessage already exists");
}
}
@ -234,8 +234,8 @@ public class Dispute implements Serializable {
return takerContractSignature;
}
public ObservableList<DisputeMailMessage> getDisputeMailMessagesAsObservableList() {
return disputeMailMessagesAsObservableList;
public ObservableList<DisputeDirectMessage> getDisputeDirectMessagesAsObservableList() {
return disputeDirectMessagesAsObservableList;
}
public boolean isClosed() {
@ -298,7 +298,7 @@ public class Dispute implements Serializable {
return false;
if (arbitratorPubKeyRing != null ? !arbitratorPubKeyRing.equals(dispute.arbitratorPubKeyRing) : dispute.arbitratorPubKeyRing != null)
return false;
if (disputeMailMessages != null ? !disputeMailMessages.equals(dispute.disputeMailMessages) : dispute.disputeMailMessages != null)
if (disputeDirectMessages != null ? !disputeDirectMessages.equals(dispute.disputeDirectMessages) : dispute.disputeDirectMessages != null)
return false;
return !(disputeResult != null ? !disputeResult.equals(dispute.disputeResult) : dispute.disputeResult != null);
@ -324,7 +324,7 @@ public class Dispute implements Serializable {
result = 31 * result + (takerContractSignature != null ? takerContractSignature.hashCode() : 0);
result = 31 * result + (arbitratorPubKeyRing != null ? arbitratorPubKeyRing.hashCode() : 0);
result = 31 * result + (isSupportTicket ? 1 : 0);
result = 31 * result + (disputeMailMessages != null ? disputeMailMessages.hashCode() : 0);
result = 31 * result + (disputeDirectMessages != null ? disputeDirectMessages.hashCode() : 0);
result = 31 * result + (isClosed ? 1 : 0);
result = 31 * result + (disputeResult != null ? disputeResult.hashCode() : 0);
return result;
@ -344,8 +344,8 @@ public class Dispute implements Serializable {
", buyerContractSignature='" + offererContractSignature + '\'' +
", sellerContractSignature='" + takerContractSignature + '\'' +
", arbitratorPubKeyRing=" + arbitratorPubKeyRing +
", disputeMailMessages=" + disputeMailMessages +
", disputeMailMessagesAsObservableList=" + disputeMailMessagesAsObservableList +
", disputeDirectMessages=" + disputeDirectMessages +
", disputeDirectMessagesAsObservableList=" + disputeDirectMessagesAsObservableList +
", isClosed=" + isClosed +
", disputeResult=" + disputeResult +
", disputeResultProperty=" + disputeResultProperty +

97
core/src/main/java/io/bitsquare/arbitration/DisputeManager.java
View file

@ -19,6 +19,7 @@ package io.bitsquare.arbitration;
import com.google.common.util.concurrent.FutureCallback;
import com.google.inject.Inject;
import io.bitsquare.app.Log;
import io.bitsquare.arbitration.messages.*;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService;
@ -69,7 +70,7 @@ public class DisputeManager {
private final String disputeInfo;
private final NetWorkReadyListener netWorkReadyListener;
private final CopyOnWriteArraySet<DecryptedMsgWithPubKey> decryptedMailboxMessageWithPubKeys = new CopyOnWriteArraySet<>();
private final CopyOnWriteArraySet<DecryptedMsgWithPubKey> decryptedMailMessageWithPubKeys = new CopyOnWriteArraySet<>();
private final CopyOnWriteArraySet<DecryptedMsgWithPubKey> decryptedDirectMessageWithPubKeys = new CopyOnWriteArraySet<>();
///////////////////////////////////////////////////////////////////////////////////////////
@ -104,8 +105,8 @@ public class DisputeManager {
"Please read more in detail about the dispute process in our wiki:\nhttps://github" +
".com/bitsquare/bitsquare/wiki/Dispute-process";
p2PService.addDecryptedMailListener((decryptedMessageWithPubKey, senderAddress) -> {
decryptedMailMessageWithPubKeys.add(decryptedMessageWithPubKey);
p2PService.addDecryptedDirectMessageListener((decryptedMessageWithPubKey, senderAddress) -> {
decryptedDirectMessageWithPubKeys.add(decryptedMessageWithPubKey);
if (p2PService.isNetworkReady())
applyMessages();
});
@ -125,12 +126,12 @@ public class DisputeManager {
}
private void applyMessages() {
decryptedMailMessageWithPubKeys.forEach(decryptedMessageWithPubKey -> {
decryptedDirectMessageWithPubKeys.forEach(decryptedMessageWithPubKey -> {
Message message = decryptedMessageWithPubKey.message;
if (message instanceof DisputeMessage)
dispatchMessage((DisputeMessage) message);
});
decryptedMailMessageWithPubKeys.clear();
decryptedDirectMessageWithPubKeys.clear();
decryptedMailboxMessageWithPubKeys.forEach(decryptedMessageWithPubKey -> {
Message message = decryptedMessageWithPubKey.message;
@ -159,8 +160,8 @@ public class DisputeManager {
onOpenNewDisputeMessage((OpenNewDisputeMessage) message);
else if (message instanceof PeerOpenedDisputeMessage)
onPeerOpenedDisputeMessage((PeerOpenedDisputeMessage) message);
else if (message instanceof DisputeMailMessage)
onDisputeMailMessage((DisputeMailMessage) message);
else if (message instanceof DisputeDirectMessage)
onDisputeDirectMessage((DisputeDirectMessage) message);
else if (message instanceof DisputeResultMessage)
onDisputeResultMessage((DisputeResultMessage) message);
else if (message instanceof PeerPublishedPayoutTxMessage)
@ -169,15 +170,15 @@ public class DisputeManager {
public void sendOpenNewDisputeMessage(Dispute dispute) {
if (!disputes.contains(dispute)) {
DisputeMailMessage disputeMailMessage = new DisputeMailMessage(dispute.getTradeId(),
DisputeDirectMessage disputeDirectMessage = new DisputeDirectMessage(dispute.getTradeId(),
keyRing.getPubKeyRing().hashCode(),
true,
"System message: " + (dispute.isSupportTicket() ?
"You opened a request for support."
: "You opened a request for a dispute.\n\n" + disputeInfo),
p2PService.getAddress());
disputeMailMessage.setIsSystemMessage(true);
dispute.addDisputeMessage(disputeMailMessage);
disputeDirectMessage.setIsSystemMessage(true);
dispute.addDisputeMessage(disputeDirectMessage);
disputes.add(dispute);
disputesObservableList.add(dispute);
@ -187,12 +188,12 @@ public class DisputeManager {
new SendMailboxMessageListener() {
@Override
public void onArrived() {
disputeMailMessage.setArrived(true);
disputeDirectMessage.setArrived(true);
}
@Override
public void onStoredInMailbox() {
disputeMailMessage.setStoredInMailbox(true);
disputeDirectMessage.setStoredInMailbox(true);
}
@Override
@ -231,15 +232,15 @@ public class DisputeManager {
disputeFromOpener.getArbitratorPubKeyRing(),
disputeFromOpener.isSupportTicket()
);
DisputeMailMessage disputeMailMessage = new DisputeMailMessage(dispute.getTradeId(),
DisputeDirectMessage disputeDirectMessage = new DisputeDirectMessage(dispute.getTradeId(),
keyRing.getPubKeyRing().hashCode(),
true,
"System message: " + (dispute.isSupportTicket() ?
"Your trading peer has requested support due technical problems. Please wait for further instructions."
: "Your trading peer has requested a dispute.\n\n" + disputeInfo),
p2PService.getAddress());
disputeMailMessage.setIsSystemMessage(true);
dispute.addDisputeMessage(disputeMailMessage);
disputeDirectMessage.setIsSystemMessage(true);
dispute.addDisputeMessage(disputeDirectMessage);
disputes.add(dispute);
disputesObservableList.add(dispute);
@ -254,12 +255,12 @@ public class DisputeManager {
new SendMailboxMessageListener() {
@Override
public void onArrived() {
disputeMailMessage.setArrived(true);
disputeDirectMessage.setArrived(true);
}
@Override
public void onStoredInMailbox() {
disputeMailMessage.setStoredInMailbox(true);
disputeDirectMessage.setStoredInMailbox(true);
}
@Override
@ -271,22 +272,22 @@ public class DisputeManager {
}
// traders send msg to the arbitrator or arbitrator to 1 trader (trader to trader is not allowed)
public DisputeMailMessage sendDisputeMailMessage(Dispute dispute, String text, ArrayList<DisputeMailMessage.Attachment> attachments) {
DisputeMailMessage disputeMailMessage = new DisputeMailMessage(dispute.getTradeId(),
public DisputeDirectMessage sendDisputeDirectMessage(Dispute dispute, String text, ArrayList<DisputeDirectMessage.Attachment> attachments) {
DisputeDirectMessage disputeDirectMessage = new DisputeDirectMessage(dispute.getTradeId(),
dispute.getTraderPubKeyRing().hashCode(),
isTrader(dispute),
text,
p2PService.getAddress());
disputeMailMessage.addAllAttachments(attachments);
disputeDirectMessage.addAllAttachments(attachments);
PubKeyRing receiverPubKeyRing = null;
NodeAddress peerNodeAddress = null;
if (isTrader(dispute)) {
dispute.addDisputeMessage(disputeMailMessage);
dispute.addDisputeMessage(disputeDirectMessage);
receiverPubKeyRing = dispute.getArbitratorPubKeyRing();
peerNodeAddress = dispute.getContract().arbitratorNodeAddress;
} else if (isArbitrator(dispute)) {
if (!disputeMailMessage.isSystemMessage())
dispute.addDisputeMessage(disputeMailMessage);
if (!disputeDirectMessage.isSystemMessage())
dispute.addDisputeMessage(disputeDirectMessage);
receiverPubKeyRing = dispute.getTraderPubKeyRing();
Contract contract = dispute.getContract();
if (contract.getBuyerPubKeyRing().equals(receiverPubKeyRing))
@ -297,19 +298,19 @@ public class DisputeManager {
log.error("That must not happen. Trader cannot communicate to other trader.");
}
if (receiverPubKeyRing != null) {
log.trace("sendDisputeMailMessage to peerAddress " + peerNodeAddress);
log.trace("sendDisputeDirectMessage to peerAddress " + peerNodeAddress);
p2PService.sendEncryptedMailboxMessage(peerNodeAddress,
receiverPubKeyRing,
disputeMailMessage,
disputeDirectMessage,
new SendMailboxMessageListener() {
@Override
public void onArrived() {
disputeMailMessage.setArrived(true);
disputeDirectMessage.setArrived(true);
}
@Override
public void onStoredInMailbox() {
disputeMailMessage.setStoredInMailbox(true);
disputeDirectMessage.setStoredInMailbox(true);
}
@Override
@ -320,18 +321,18 @@ public class DisputeManager {
);
}
return disputeMailMessage;
return disputeDirectMessage;
}
// arbitrator send result to trader
public void sendDisputeResultMessage(DisputeResult disputeResult, Dispute dispute, String text) {
DisputeMailMessage disputeMailMessage = new DisputeMailMessage(dispute.getTradeId(),
DisputeDirectMessage disputeDirectMessage = new DisputeDirectMessage(dispute.getTradeId(),
dispute.getTraderPubKeyRing().hashCode(),
false,
text,
p2PService.getAddress());
dispute.addDisputeMessage(disputeMailMessage);
disputeResult.setResultMailMessage(disputeMailMessage);
dispute.addDisputeMessage(disputeDirectMessage);
disputeResult.setDisputeDirectMessage(disputeDirectMessage);
NodeAddress peerNodeAddress;
Contract contract = dispute.getContract();
@ -345,12 +346,12 @@ public class DisputeManager {
new SendMailboxMessageListener() {
@Override
public void onArrived() {
disputeMailMessage.setArrived(true);
disputeDirectMessage.setArrived(true);
}
@Override
public void onStoredInMailbox() {
disputeMailMessage.setStoredInMailbox(true);
disputeDirectMessage.setStoredInMailbox(true);
}
@Override
@ -431,17 +432,17 @@ public class DisputeManager {
}
// a trader can receive a msg from the arbitrator or the arbitrator form a trader. Trader to trader is not allowed.
private void onDisputeMailMessage(DisputeMailMessage disputeMailMessage) {
log.debug("onDisputeMailMessage " + disputeMailMessage);
Optional<Dispute> disputeOptional = findDispute(disputeMailMessage.getTradeId(), disputeMailMessage.getTraderId());
private void onDisputeDirectMessage(DisputeDirectMessage disputeDirectMessage) {
Log.traceCall("disputeDirectMessage " + disputeDirectMessage);
Optional<Dispute> disputeOptional = findDispute(disputeDirectMessage.getTradeId(), disputeDirectMessage.getTraderId());
if (disputeOptional.isPresent()) {
Dispute dispute = disputeOptional.get();
if (!dispute.getDisputeMailMessagesAsObservableList().contains(disputeMailMessage))
dispute.addDisputeMessage(disputeMailMessage);
if (!dispute.getDisputeDirectMessagesAsObservableList().contains(disputeDirectMessage))
dispute.addDisputeMessage(disputeDirectMessage);
else
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeMailMessage.getTradeId());
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeDirectMessage.getTradeId());
} else {
log.warn("We got a dispute mail msg but we don't have a matching dispute. TradeId = " + disputeMailMessage.getTradeId());
log.warn("We got a dispute mail msg but we don't have a matching dispute. TradeId = " + disputeDirectMessage.getTradeId());
}
}
@ -453,11 +454,11 @@ public class DisputeManager {
if (disputeOptional.isPresent()) {
Dispute dispute = disputeOptional.get();
DisputeMailMessage disputeMailMessage = disputeResult.getResultMailMessage();
if (!dispute.getDisputeMailMessagesAsObservableList().contains(disputeMailMessage))
dispute.addDisputeMessage(disputeMailMessage);
DisputeDirectMessage disputeDirectMessage = disputeResult.getDisputeDirectMessage();
if (!dispute.getDisputeDirectMessagesAsObservableList().contains(disputeDirectMessage))
dispute.addDisputeMessage(disputeDirectMessage);
else
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeMailMessage.getTradeId());
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeDirectMessage.getTradeId());
dispute.setIsClosed(true);
if (tradeManager.getTradeById(dispute.getTradeId()).isPresent())
@ -529,11 +530,11 @@ public class DisputeManager {
log.warn("We got a dispute msg what we have already stored. TradeId = " + disputeResult.tradeId);
}
/* DisputeMailMessage disputeMailMessage = disputeResult.getResultMailMessage();
if (!dispute.getDisputeMailMessagesAsObservableList().contains(disputeMailMessage))
dispute.addDisputeMessage(disputeMailMessage);
/* DisputeMailMessage disputeDirectMessage = disputeResult.getResultMailMessage();
if (!dispute.getDisputeMailMessagesAsObservableList().contains(disputeDirectMessage))
dispute.addDisputeMessage(disputeDirectMessage);
else
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeMailMessage.getTradeId());*/
log.warn("We got a dispute mail msg what we have already stored. TradeId = " + disputeDirectMessage.getTradeId());*/
} else {
log.warn("We got a dispute result msg but we don't have a matching dispute. TradeId = " + disputeResult.tradeId);

16
core/src/main/java/io/bitsquare/arbitration/DisputeResult.java
View file

@ -18,7 +18,7 @@
package io.bitsquare.arbitration;
import io.bitsquare.app.Version;
import io.bitsquare.arbitration.messages.DisputeMailMessage;
import io.bitsquare.arbitration.messages.DisputeDirectMessage;
import javafx.beans.property.*;
import org.bitcoinj.core.Coin;
import org.slf4j.Logger;
@ -55,7 +55,7 @@ public class DisputeResult implements Serializable {
private boolean idVerification;
private boolean screenCast;
private String summaryNotes;
private DisputeMailMessage resultMailMessage;
private DisputeDirectMessage disputeDirectMessage;
private byte[] arbitratorSignature;
private long buyerPayoutAmount;
private long sellerPayoutAmount;
@ -142,12 +142,12 @@ public class DisputeResult implements Serializable {
return summaryNotesProperty;
}
public void setResultMailMessage(DisputeMailMessage resultMailMessage) {
this.resultMailMessage = resultMailMessage;
public void setDisputeDirectMessage(DisputeDirectMessage disputeDirectMessage) {
this.disputeDirectMessage = disputeDirectMessage;
}
public DisputeMailMessage getResultMailMessage() {
return resultMailMessage;
public DisputeDirectMessage getDisputeDirectMessage() {
return disputeDirectMessage;
}
public void setArbitratorSignature(byte[] arbitratorSignature) {
@ -232,7 +232,7 @@ public class DisputeResult implements Serializable {
if (tradeId != null ? !tradeId.equals(that.tradeId) : that.tradeId != null) return false;
if (feePaymentPolicy != that.feePaymentPolicy) return false;
if (summaryNotes != null ? !summaryNotes.equals(that.summaryNotes) : that.summaryNotes != null) return false;
if (resultMailMessage != null ? !resultMailMessage.equals(that.resultMailMessage) : that.resultMailMessage != null)
if (disputeDirectMessage != null ? !disputeDirectMessage.equals(that.disputeDirectMessage) : that.disputeDirectMessage != null)
return false;
if (!Arrays.equals(arbitratorSignature, that.arbitratorSignature)) return false;
if (arbitratorAddressAsString != null ? !arbitratorAddressAsString.equals(that.arbitratorAddressAsString) : that.arbitratorAddressAsString != null)
@ -251,7 +251,7 @@ public class DisputeResult implements Serializable {
result = 31 * result + (idVerification ? 1 : 0);
result = 31 * result + (screenCast ? 1 : 0);
result = 31 * result + (summaryNotes != null ? summaryNotes.hashCode() : 0);
result = 31 * result + (resultMailMessage != null ? resultMailMessage.hashCode() : 0);
result = 31 * result + (disputeDirectMessage != null ? disputeDirectMessage.hashCode() : 0);
result = 31 * result + (arbitratorSignature != null ? Arrays.hashCode(arbitratorSignature) : 0);
result = 31 * result + (int) (buyerPayoutAmount ^ (buyerPayoutAmount >>> 32));
result = 31 * result + (int) (sellerPayoutAmount ^ (sellerPayoutAmount >>> 32));

12
core/src/main/java/io/bitsquare/arbitration/messages/DisputeMailMessage.java → core/src/main/java/io/bitsquare/arbitration/messages/DisputeDirectMessage.java
View file

@ -32,10 +32,10 @@ import java.util.Arrays;
import java.util.Date;
import java.util.List;
public final class DisputeMailMessage extends DisputeMessage {
public final class DisputeDirectMessage extends DisputeMessage {
// That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = Version.NETWORK_PROTOCOL_VERSION;
private static final Logger log = LoggerFactory.getLogger(DisputeMailMessage.class);
private static final Logger log = LoggerFactory.getLogger(DisputeDirectMessage.class);
private final long date;
private final String tradeId;
@ -52,7 +52,7 @@ public final class DisputeMailMessage extends DisputeMessage {
transient private BooleanProperty arrivedProperty = new SimpleBooleanProperty();
transient private BooleanProperty storedInMailboxProperty = new SimpleBooleanProperty();
public DisputeMailMessage(String tradeId, int traderId, boolean senderIsTrader, String message, NodeAddress myNodeAddress) {
public DisputeDirectMessage(String tradeId, int traderId, boolean senderIsTrader, String message, NodeAddress myNodeAddress) {
this.tradeId = tradeId;
this.traderId = traderId;
this.senderIsTrader = senderIsTrader;
@ -137,9 +137,9 @@ public final class DisputeMailMessage extends DisputeMessage {
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof DisputeMailMessage)) return false;
if (!(o instanceof DisputeDirectMessage)) return false;
DisputeMailMessage that = (DisputeMailMessage) o;
DisputeDirectMessage that = (DisputeDirectMessage) o;
if (date != that.date) return false;
if (traderId != that.traderId) return false;
@ -171,7 +171,7 @@ public final class DisputeMailMessage extends DisputeMessage {
@Override
public String toString() {
return "DisputeMailMessage{" +
return "DisputeDirectMessage{" +
"date=" + date +
", tradeId='" + tradeId + '\'' +
", traderId='" + traderId + '\'' +

12
core/src/main/java/io/bitsquare/trade/TradeManager.java
View file

@ -23,7 +23,6 @@ import io.bitsquare.arbitration.ArbitratorManager;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService;
import io.bitsquare.common.UserThread;
import io.bitsquare.common.crypto.KeyRing;
import io.bitsquare.common.handlers.FaultHandler;
import io.bitsquare.common.handlers.ResultHandler;
@ -31,7 +30,7 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.NetWorkReadyListener;
import io.bitsquare.p2p.NodeAddress;
import io.bitsquare.p2p.P2PService;
import io.bitsquare.p2p.messaging.DecryptedMailListener;
import io.bitsquare.p2p.messaging.DecryptedDirectMessageListener;
import io.bitsquare.p2p.messaging.DecryptedMailboxListener;
import io.bitsquare.p2p.messaging.DecryptedMsgWithPubKey;
import io.bitsquare.storage.Storage;
@ -62,7 +61,6 @@ import javax.inject.Named;
import java.io.File;
import java.util.Date;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import static io.bitsquare.util.Validator.nonEmptyStringOf;
@ -114,9 +112,9 @@ public class TradeManager {
tradableListStorage = new Storage<>(storageDir);
this.trades = new TradableList<>(tradableListStorage, "PendingTrades");
p2PService.addDecryptedMailListener(new DecryptedMailListener() {
p2PService.addDecryptedDirectMessageListener(new DecryptedDirectMessageListener() {
@Override
public void onMailMessage(DecryptedMsgWithPubKey decryptedMsgWithPubKey, NodeAddress peerNodeAddress) {
public void onDirectMessage(DecryptedMsgWithPubKey decryptedMsgWithPubKey, NodeAddress peerNodeAddress) {
Message message = decryptedMsgWithPubKey.message;
// Handler for incoming initial messages from taker
@ -153,8 +151,8 @@ public class TradeManager {
@Override
public void onBootstrapped() {
Log.traceCall("onNetworkReady");
// give a bit delay to be sure other listeners have executed its work
UserThread.runAfter(() -> initPendingTrades(), 100, TimeUnit.MILLISECONDS);
// Get called after onMailboxMessageAdded from initial data request
initPendingTrades();
}
};
p2PService.addP2PServiceListener(netWorkReadyListener);

8
core/src/main/java/io/bitsquare/trade/offer/OpenOfferManager.java
View file

@ -28,7 +28,7 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.NetWorkReadyListener;
import io.bitsquare.p2p.NodeAddress;
import io.bitsquare.p2p.P2PService;
import io.bitsquare.p2p.messaging.SendMailMessageListener;
import io.bitsquare.p2p.messaging.SendDirectMessageListener;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.TradableList;
import io.bitsquare.trade.closed.ClosedTradableManager;
@ -103,7 +103,7 @@ public class OpenOfferManager {
"OpenOfferManager.ShutDownHook"));
// Handler for incoming offer availability requests
p2PService.addDecryptedMailListener((decryptedMessageWithPubKey, peersNodeAddress) -> {
p2PService.addDecryptedDirectMessageListener((decryptedMessageWithPubKey, peersNodeAddress) -> {
// We get an encrypted message but don't do the signature check as we don't know the peer yet.
// A basic sig check is in done also at decryption time
Message message = decryptedMessageWithPubKey.message;
@ -295,10 +295,10 @@ public class OpenOfferManager {
Optional<OpenOffer> openOfferOptional = findOpenOffer(message.offerId);
boolean isAvailable = openOfferOptional.isPresent() && openOfferOptional.get().getState() == OpenOffer.State.AVAILABLE;
try {
p2PService.sendEncryptedMailMessage(sender,
p2PService.sendEncryptedDirectMessage(sender,
message.getPubKeyRing(),
new OfferAvailabilityResponse(message.offerId, isAvailable),
new SendMailMessageListener() {
new SendDirectMessageListener() {
@Override
public void onArrived() {
log.trace("OfferAvailabilityResponse successfully arrived at peer");

10
core/src/main/java/io/bitsquare/trade/protocol/availability/OfferAvailabilityProtocol.java
View file

@ -22,7 +22,7 @@ import io.bitsquare.common.handlers.ErrorMessageHandler;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.messaging.DecryptedMailListener;
import io.bitsquare.p2p.messaging.DecryptedDirectMessageListener;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.availability.messages.OfferAvailabilityResponse;
import io.bitsquare.trade.protocol.availability.messages.OfferMessage;
@ -41,7 +41,7 @@ public class OfferAvailabilityProtocol {
private final OfferAvailabilityModel model;
private final ResultHandler resultHandler;
private final ErrorMessageHandler errorMessageHandler;
private final DecryptedMailListener decryptedMailListener;
private final DecryptedDirectMessageListener decryptedDirectMessageListener;
private TaskRunner<OfferAvailabilityModel> taskRunner;
private java.util.Timer timeoutTimer;
@ -56,7 +56,7 @@ public class OfferAvailabilityProtocol {
this.resultHandler = resultHandler;
this.errorMessageHandler = errorMessageHandler;
decryptedMailListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
decryptedDirectMessageListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
Message message = decryptedMessageWithPubKey.message;
if (message instanceof OfferMessage) {
OfferMessage offerMessage = (OfferMessage) message;
@ -72,7 +72,7 @@ public class OfferAvailabilityProtocol {
private void cleanup() {
stopTimeout();
model.p2PService.removeDecryptedMailListener(decryptedMailListener);
model.p2PService.removeDecryptedMailListener(decryptedDirectMessageListener);
}
@ -84,7 +84,7 @@ public class OfferAvailabilityProtocol {
// reset
model.offer.setState(Offer.State.UNDEFINED);
model.p2PService.addDecryptedMailListener(decryptedMailListener);
model.p2PService.addDecryptedDirectMessageListener(decryptedDirectMessageListener);
model.setPeerNodeAddress(model.offer.getOffererNodeAddress());
taskRunner = new TaskRunner<>(model,

4
core/src/main/java/io/bitsquare/trade/protocol/availability/messages/OfferMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.availability.messages;
import io.bitsquare.app.Version;
import io.bitsquare.p2p.messaging.MailMessage;
import io.bitsquare.p2p.messaging.DirectMessage;
import javax.annotation.concurrent.Immutable;
@Immutable
public abstract class OfferMessage implements MailMessage {
public abstract class OfferMessage implements DirectMessage {
// That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = Version.NETWORK_PROTOCOL_VERSION;

6
core/src/main/java/io/bitsquare/trade/protocol/availability/tasks/SendOfferAvailabilityRequest.java
View file

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.availability.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.messaging.SendMailMessageListener;
import io.bitsquare.p2p.messaging.SendDirectMessageListener;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel;
import io.bitsquare.trade.protocol.availability.messages.OfferAvailabilityRequest;
@ -38,10 +38,10 @@ public class SendOfferAvailabilityRequest extends Task<OfferAvailabilityModel> {
try {
runInterceptHook();
model.p2PService.sendEncryptedMailMessage(model.getPeerNodeAddress(),
model.p2PService.sendEncryptedDirectMessage(model.getPeerNodeAddress(),
model.offer.getPubKeyRing(),
new OfferAvailabilityRequest(model.offer.getId(), model.getPubKeyRing()),
new SendMailMessageListener() {
new SendDirectMessageListener() {
@Override
public void onArrived() {
complete();

1
core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java
View file

@ -113,7 +113,6 @@ public class ProcessModel implements Model, Serializable {
this.p2PService = p2PService;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter only
///////////////////////////////////////////////////////////////////////////////////////////

10
core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java
View file

@ -21,7 +21,7 @@ import io.bitsquare.common.UserThread;
import io.bitsquare.common.crypto.PubKeyRing;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.NodeAddress;
import io.bitsquare.p2p.messaging.DecryptedMailListener;
import io.bitsquare.p2p.messaging.DecryptedDirectMessageListener;
import io.bitsquare.p2p.messaging.DecryptedMsgWithPubKey;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
@ -41,7 +41,7 @@ public abstract class TradeProtocol {
private static final long TIMEOUT_SEC = 30;
protected final ProcessModel processModel;
private final DecryptedMailListener decryptedMailListener;
private final DecryptedDirectMessageListener decryptedDirectMessageListener;
protected Trade trade;
private java.util.Timer timeoutTimer;
@ -49,7 +49,7 @@ public abstract class TradeProtocol {
this.trade = trade;
this.processModel = trade.getProcessModel();
decryptedMailListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
decryptedDirectMessageListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
// We check the sig only as soon we have stored the peers pubKeyRing.
PubKeyRing tradingPeerPubKeyRing = processModel.tradingPeer.getPubKeyRing();
PublicKey signaturePubKey = decryptedMessageWithPubKey.signaturePubKey;
@ -77,7 +77,7 @@ public abstract class TradeProtocol {
log.error("Signature used in seal message does not match the one stored with that trade for the trading peer or arbitrator.");*/
}
};
processModel.getP2PService().addDecryptedMailListener(decryptedMailListener);
processModel.getP2PService().addDecryptedDirectMessageListener(decryptedDirectMessageListener);
}
public void completed() {
@ -88,7 +88,7 @@ public abstract class TradeProtocol {
log.debug("cleanup " + this);
stopTimeout();
processModel.getP2PService().removeDecryptedMailListener(decryptedMailListener);
processModel.getP2PService().removeDecryptedMailListener(decryptedDirectMessageListener);
}

4
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/TradeMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.messages;
import io.bitsquare.app.Version;
import io.bitsquare.p2p.messaging.MailMessage;
import io.bitsquare.p2p.messaging.DirectMessage;
import javax.annotation.concurrent.Immutable;
@Immutable
public abstract class TradeMessage implements MailMessage {
public abstract class TradeMessage implements DirectMessage {
// That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = Version.NETWORK_PROTOCOL_VERSION;

13
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/TradeTask.java
View file

@ -19,6 +19,8 @@ package io.bitsquare.trade.protocol.trade.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.messaging.DecryptedMsgWithPubKey;
import io.bitsquare.p2p.messaging.MailboxMessage;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import org.slf4j.Logger;
@ -57,4 +59,15 @@ public abstract class TradeTask extends Task<Trade> {
trade.setErrorMessage(errorMessage);
super.failed();
}
protected void removeMailboxMessageAfterProcessing() {
if (processModel.getTradeMessage() instanceof MailboxMessage) {
DecryptedMsgWithPubKey mailboxMessage = trade.getMailboxMessage();
if (mailboxMessage != null && mailboxMessage.message.equals(processModel.getTradeMessage())) {
log.info("Remove mailboxMessage from P2P network. mailboxMessage = " + mailboxMessage);
processModel.getP2PService().removeEntryFromMailbox(mailboxMessage);
trade.setMailboxMessage(null);
}
}
}
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessFinalizePayoutTxRequest.java
View file

@ -52,6 +52,8 @@ public class ProcessFinalizePayoutTxRequest extends TradeTask {
// update to the latest peer address of our peer if the message is correct
trade.setTradingPeerNodeAddress(processModel.getTempTradingPeerNodeAddress());
removeMailboxMessageAfterProcessing();
complete();
} catch (Throwable t) {
failed(t);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/offerer/ProcessDepositTxPublishedMessage.java
View file

@ -57,6 +57,8 @@ public class ProcessDepositTxPublishedMessage extends TradeTask {
// update to the latest peer address of our peer if the message is correct
trade.setTradingPeerNodeAddress(processModel.getTempTradingPeerNodeAddress());
removeMailboxMessageAfterProcessing();
complete();
} catch (Throwable t) {
failed(t);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/offerer/ProcessPayDepositRequest.java
View file

@ -82,6 +82,8 @@ public class ProcessPayDepositRequest extends TradeTask {
// update to the latest peer address of our peer if the payDepositRequest is correct
trade.setTradingPeerNodeAddress(processModel.getTempTradingPeerNodeAddress());
removeMailboxMessageAfterProcessing();
complete();
} catch (Throwable t) {
failed(t);

6
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/offerer/SendPublishDepositTxRequest.java
View file

@ -18,7 +18,7 @@
package io.bitsquare.trade.protocol.trade.tasks.offerer;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.messaging.SendMailMessageListener;
import io.bitsquare.p2p.messaging.SendDirectMessageListener;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.TradeTask;
@ -51,11 +51,11 @@ public class SendPublishDepositTxRequest extends TradeTask {
trade.getCheckPaymentTimeAsBlockHeight()
);
processModel.getP2PService().sendEncryptedMailMessage(
processModel.getP2PService().sendEncryptedDirectMessage(
trade.getTradingPeerNodeAddress(),
processModel.tradingPeer.getPubKeyRing(),
tradeMessage,
new SendMailMessageListener() {
new SendDirectMessageListener() {
@Override
public void onArrived() {
log.trace("Message arrived at peer.");

2
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java
View file

@ -51,6 +51,8 @@ public class ProcessFiatTransferStartedMessage extends TradeTask {
// update to the latest peer address of our peer if the message is correct
trade.setTradingPeerNodeAddress(processModel.getTempTradingPeerNodeAddress());
removeMailboxMessageAfterProcessing();
complete();
} catch (Throwable t) {
failed(t);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java
View file

@ -51,6 +51,8 @@ public class ProcessPayoutTxFinalizedMessage extends TradeTask {
// update to the latest peer address of our peer if the message is correct
trade.setTradingPeerNodeAddress(processModel.getTempTradingPeerNodeAddress());
removeMailboxMessageAfterProcessing();
complete();
} catch (Throwable t) {
failed(t);