mirrors/bisq
1
0
Fork 0
mirror of https://github.com/bisq-network/bisq.git synced 2025-02-24 15:10:44 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove sendEncryptedMailboxMessage from P2PService and use MailboxMessageService instead

Browse source
This commit is contained in:
chimp1984 2021-01-10 18:40:20 -05:00
parent 33703c269c
commit b8fc7f3985
No known key found for this signature in database
GPG key ID: 9801B4EC591F90E3
8 changed files with 17 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/src/main/java/bisq/core/alert/PrivateNotificationManager.java
View file

@ -127,7 +127,7 @@ public class PrivateNotificationManager {
UUID.randomUUID().toString());
log.info("Send {} to peer {}. uid={}",
message.getClass().getSimpleName(), peersNodeAddress, message.getUid());
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(peersNodeAddress,
pubKeyRing,
message,
sendMailboxMessageListener);

14
core/src/main/java/bisq/core/support/SupportManager.java
View file

@ -27,6 +27,7 @@ import bisq.network.p2p.DecryptedMessageWithPubKey;
import bisq.network.p2p.NodeAddress;
import bisq.network.p2p.P2PService;
import bisq.network.p2p.SendMailboxMessageListener;
import bisq.network.p2p.mailbox.MailboxMessageService;
import bisq.common.Timer;
import bisq.common.UserThread;
@ -49,6 +50,7 @@ public abstract class SupportManager {
protected final Map<String, Timer> delayMsgMap = new HashMap<>();
private final CopyOnWriteArraySet<DecryptedMessageWithPubKey> decryptedMailboxMessageWithPubKeys = new CopyOnWriteArraySet<>();
private final CopyOnWriteArraySet<DecryptedMessageWithPubKey> decryptedDirectMessageWithPubKeys = new CopyOnWriteArraySet<>();
protected final MailboxMessageService mailboxMessageService;
private boolean allServicesInitialized;
@ -58,6 +60,8 @@ public abstract class SupportManager {
public SupportManager(P2PService p2PService, WalletsSetup walletsSetup) {
this.p2PService = p2PService;
mailboxMessageService = p2PService.getMailboxMessageService();
this.walletsSetup = walletsSetup;
// We get first the message handler called then the onBootstrapped
@ -67,7 +71,7 @@ public abstract class SupportManager {
decryptedDirectMessageWithPubKeys.add(decryptedMessageWithPubKey);
tryApplyMessages();
});
p2PService.getMailboxMessageService().addDecryptedMailboxListener((decryptedMessageWithPubKey, senderAddress) -> {
mailboxMessageService.addDecryptedMailboxListener((decryptedMessageWithPubKey, senderAddress) -> {
// As decryptedMailboxMessageWithPubKeys is a CopyOnWriteArraySet we do not need to check if it was
// already stored
decryptedMailboxMessageWithPubKeys.add(decryptedMessageWithPubKey);
@ -177,7 +181,7 @@ public abstract class SupportManager {
requestPersistence();
if (decryptedMessageWithPubKey != null)
p2PService.getMailboxMessageService().removeMailboxMsg(decryptedMessageWithPubKey);
mailboxMessageService.removeMailboxMsg(decryptedMessageWithPubKey);
}
}
@ -195,7 +199,7 @@ public abstract class SupportManager {
log.info("Send {} to peer {}. tradeId={}, uid={}",
message.getClass().getSimpleName(), peersNodeAddress, message.getTradeId(), message.getUid());
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(peersNodeAddress,
receiverPubKeyRing,
message,
new SendMailboxMessageListener() {
@ -243,7 +247,7 @@ public abstract class SupportManager {
final NodeAddress peersNodeAddress = supportMessage.getSenderNodeAddress();
log.info("Send AckMessage for {} to peer {}. tradeId={}, uid={}",
ackMessage.getSourceMsgClassName(), peersNodeAddress, tradeId, uid);
p2PService.sendEncryptedMailboxMessage(
mailboxMessageService.sendEncryptedMailboxMessage(
peersNodeAddress,
peersPubKeyRing,
ackMessage,
@ -314,7 +318,7 @@ public abstract class SupportManager {
log.debug("decryptedMessageWithPubKey.message " + networkEnvelope);
if (networkEnvelope instanceof SupportMessage) {
dispatchMessage((SupportMessage) networkEnvelope);
p2PService.getMailboxMessageService().removeMailboxMsg(decryptedMessageWithPubKey);
mailboxMessageService.removeMailboxMsg(decryptedMessageWithPubKey);
} else if (networkEnvelope instanceof AckMessage) {
onAckMessage((AckMessage) networkEnvelope, decryptedMessageWithPubKey);
}

6
core/src/main/java/bisq/core/support/dispute/DisputeManager.java
View file

@ -483,7 +483,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
openNewDisputeMessage.getUid(),
chatMessage.getUid());
p2PService.sendEncryptedMailboxMessage(agentNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(agentNodeAddress,
dispute.getAgentPubKeyRing(),
openNewDisputeMessage,
new SendMailboxMessageListener() {
@ -629,7 +629,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
peerOpenedDisputeMessage.getTradeId(), peerOpenedDisputeMessage.getUid(),
chatMessage.getUid());
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(peersNodeAddress,
peersPubKeyRing,
peerOpenedDisputeMessage,
new SendMailboxMessageListener() {
@ -711,7 +711,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
log.info("Send {} to peer {}. tradeId={}, disputeResultMessage.uid={}, chatMessage.uid={}",
disputeResultMessage.getClass().getSimpleName(), peersNodeAddress, disputeResultMessage.getTradeId(),
disputeResultMessage.getUid(), chatMessage.getUid());
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(peersNodeAddress,
dispute.getTraderPubKeyRing(),
disputeResultMessage,
new SendMailboxMessageListener() {

2
core/src/main/java/bisq/core/support/dispute/arbitration/ArbitrationManager.java
View file

@ -393,7 +393,7 @@ public final class ArbitrationManager extends DisputeManager<ArbitrationDisputeL
getSupportType());
log.info("Send {} to peer {}. tradeId={}, uid={}",
message.getClass().getSimpleName(), peersNodeAddress, message.getTradeId(), message.getUid());
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
mailboxMessageService.sendEncryptedMailboxMessage(peersNodeAddress,
peersPubKeyRing,
message,
new SendMailboxMessageListener() {

2
core/src/main/java/bisq/core/trade/protocol/TradeProtocol.java
View file

@ -269,7 +269,7 @@ public abstract class TradeProtocol implements DecryptedDirectMessageListener, D
processModel.getTempTradingPeerNodeAddress();
log.info("Send AckMessage for {} to peer {}. tradeId={}, sourceUid={}",
ackMessage.getSourceMsgClassName(), peer, tradeId, sourceUid);
processModel.getP2PService().sendEncryptedMailboxMessage(
processModel.getP2PService().getMailboxMessageService().sendEncryptedMailboxMessage(
peer,
peersPubKeyRing,
ackMessage,

2
core/src/main/java/bisq/core/trade/protocol/tasks/SendMailboxMessageTask.java
View file

@ -54,7 +54,7 @@ public abstract class SendMailboxMessageTask extends TradeTask {
log.info("Send {} to peer {}. tradeId={}, uid={}",
message.getClass().getSimpleName(), peersNodeAddress, message.getTradeId(), message.getUid());
processModel.getP2PService().sendEncryptedMailboxMessage(
processModel.getP2PService().getMailboxMessageService().sendEncryptedMailboxMessage(
peersNodeAddress,
processModel.getTradingPeer().getPubKeyRing(),
message,

2
core/src/main/java/bisq/core/trade/protocol/tasks/mediation/SendMediatedPayoutSignatureMessage.java
View file

@ -61,7 +61,7 @@ public class SendMediatedPayoutSignatureMessage extends TradeTask {
trade.setMediationResultState(MediationResultState.SIG_MSG_SENT);
processModel.getTradeManager().requestPersistence();
p2PService.sendEncryptedMailboxMessage(peersNodeAddress,
p2PService.getMailboxMessageService().sendEncryptedMailboxMessage(peersNodeAddress,
peersPubKeyRing,
message,
new SendMailboxMessageListener() {

7
p2p/src/main/java/bisq/network/p2p/P2PService.java
View file

@ -479,13 +479,6 @@ public class P2PService implements SetupListener, MessageListener, ConnectionLis
// MailboxMessages
///////////////////////////////////////////////////////////////////////////////////////////
public void sendEncryptedMailboxMessage(NodeAddress peer, PubKeyRing peersPubKeyRing,
NetworkEnvelope message,
SendMailboxMessageListener sendMailboxMessageListener) {
//todo
mailboxMessageService.sendEncryptedMailboxMessage(peer, peersPubKeyRing, message, sendMailboxMessageListener);
}
private boolean capabilityRequiredAndCapabilityNotSupported(NodeAddress peersNodeAddress, NetworkEnvelope message) {
if (!(message instanceof CapabilityRequiringPayload))
return false;