Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-07-27 17:05:29 -04:00
Code Issues Projects Releases Packages Wiki Activity

Remove authentication for P2P network, UI improvements

Browse source
This commit is contained in:
Manfred Karrer 2016-01-24 20:30:33 +01:00
parent 17fa8a424a
commit 2ad72938ec
65 changed files with 1351 additions and 2275 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -26,7 +26,7 @@ import io.bitsquare.common.crypto.KeyRing;
import io.bitsquare.common.handlers.ErrorMessageHandler;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.common.util.Utilities;
import io.bitsquare.p2p.FirstPeerAuthenticatedListener;
import io.bitsquare.p2p.NetWorkReadyListener;
import io.bitsquare.p2p.NodeAddress;
import io.bitsquare.p2p.P2PService;
import io.bitsquare.p2p.storage.HashMapChangedListener;
@ -89,7 +89,7 @@ public class ArbitratorManager {
));
private static final String publicKeyForTesting = "027a381b5333a56e1cc3d90d3a7d07f26509adf7029ed06fc997c656621f8da1ee";
private final boolean isDevTest;
private FirstPeerAuthenticatedListener firstPeerAuthenticatedListener;
private NetWorkReadyListener netWorkReadyListener;
private ScheduledThreadPoolExecutor republishArbitratorExecutor;
@Inject
@ -121,14 +121,14 @@ public class ArbitratorManager {
if (user.getRegisteredArbitrator() != null) {
P2PService p2PService = arbitratorService.getP2PService();
if (!p2PService.isAuthenticated()) {
firstPeerAuthenticatedListener = new FirstPeerAuthenticatedListener() {
if (!p2PService.isNetworkReady()) {
netWorkReadyListener = new NetWorkReadyListener() {
@Override
public void onFirstPeerAuthenticated() {
public void onBootstrapped() {
republishArbitrator();
}
};
p2PService.addP2PServiceListener(firstPeerAuthenticatedListener);
p2PService.addP2PServiceListener(netWorkReadyListener);
} else {
republishArbitrator();
@ -144,8 +144,8 @@ public class ArbitratorManager {
}
private void republishArbitrator() {
if (firstPeerAuthenticatedListener != null)
arbitratorService.getP2PService().removeP2PServiceListener(firstPeerAuthenticatedListener);
if (netWorkReadyListener != null)
arbitratorService.getP2PService().removeP2PServiceListener(netWorkReadyListener);
Arbitrator registeredArbitrator = user.getRegisteredArbitrator();
if (registeredArbitrator != null) {

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

@ -26,8 +26,8 @@ import io.bitsquare.btc.exceptions.TransactionVerificationException;
import io.bitsquare.btc.exceptions.WalletException;
import io.bitsquare.common.crypto.KeyRing;
import io.bitsquare.common.crypto.PubKeyRing;
import io.bitsquare.p2p.FirstPeerAuthenticatedListener;
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.DecryptedMsgWithPubKey;
@ -67,7 +67,7 @@ public class DisputeManager {
private final DisputeList<Dispute> disputes;
transient private final ObservableList<Dispute> disputesObservableList;
private final String disputeInfo;
private final FirstPeerAuthenticatedListener firstPeerAuthenticatedListener;
private final NetWorkReadyListener netWorkReadyListener;
private final CopyOnWriteArraySet<DecryptedMsgWithPubKey> decryptedMailboxMessageWithPubKeys = new CopyOnWriteArraySet<>();
private final CopyOnWriteArraySet<DecryptedMsgWithPubKey> decryptedMailMessageWithPubKeys = new CopyOnWriteArraySet<>();
@ -106,22 +106,22 @@ public class DisputeManager {
p2PService.addDecryptedMailListener((decryptedMessageWithPubKey, senderAddress) -> {
decryptedMailMessageWithPubKeys.add(decryptedMessageWithPubKey);
if (p2PService.isAuthenticated())
if (p2PService.isNetworkReady())
applyMessages();
});
p2PService.addDecryptedMailboxListener((decryptedMessageWithPubKey, senderAddress) -> {
decryptedMailboxMessageWithPubKeys.add(decryptedMessageWithPubKey);
if (p2PService.isAuthenticated())
if (p2PService.isNetworkReady())
applyMessages();
});
firstPeerAuthenticatedListener = new FirstPeerAuthenticatedListener() {
netWorkReadyListener = new NetWorkReadyListener() {
@Override
public void onFirstPeerAuthenticated() {
public void onBootstrapped() {
applyMessages();
}
};
p2PService.addP2PServiceListener(firstPeerAuthenticatedListener);
p2PService.addP2PServiceListener(netWorkReadyListener);
}
private void applyMessages() {
@ -143,7 +143,7 @@ public class DisputeManager {
});
decryptedMailboxMessageWithPubKeys.clear();
p2PService.removeP2PServiceListener(firstPeerAuthenticatedListener);
p2PService.removeP2PServiceListener(netWorkReadyListener);
}

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

@ -18,6 +18,7 @@
package io.bitsquare.trade;
import com.google.common.util.concurrent.FutureCallback;
import io.bitsquare.app.Log;
import io.bitsquare.arbitration.ArbitratorManager;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.TradeWalletService;
@ -26,8 +27,8 @@ import io.bitsquare.common.UserThread;
import io.bitsquare.common.crypto.KeyRing;
import io.bitsquare.common.handlers.FaultHandler;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.p2p.FirstPeerAuthenticatedListener;
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;
@ -81,7 +82,7 @@ public class TradeManager {
private final Storage<TradableList<Trade>> tradableListStorage;
private final TradableList<Trade> trades;
private final BooleanProperty pendingTradesInitialized = new SimpleBooleanProperty();
private final FirstPeerAuthenticatedListener firstPeerAuthenticatedListener;
private final NetWorkReadyListener netWorkReadyListener;
///////////////////////////////////////////////////////////////////////////////////////////
@ -99,6 +100,7 @@ public class TradeManager {
ArbitratorManager arbitratorManager,
P2PService p2PService,
@Named("storage.dir") File storageDir) {
Log.traceCall();
this.user = user;
this.keyRing = keyRing;
this.walletService = walletService;
@ -147,14 +149,15 @@ public class TradeManager {
}
});
firstPeerAuthenticatedListener = new FirstPeerAuthenticatedListener() {
netWorkReadyListener = new NetWorkReadyListener() {
@Override
public void onFirstPeerAuthenticated() {
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);
}
};
p2PService.addP2PServiceListener(firstPeerAuthenticatedListener);
p2PService.addP2PServiceListener(netWorkReadyListener);
}
@ -163,7 +166,8 @@ public class TradeManager {
///////////////////////////////////////////////////////////////////////////////////////////
private void initPendingTrades() {
if (firstPeerAuthenticatedListener != null) p2PService.removeP2PServiceListener(firstPeerAuthenticatedListener);
Log.traceCall();
if (netWorkReadyListener != null) p2PService.removeP2PServiceListener(netWorkReadyListener);
//List<Trade> failedTrades = new ArrayList<>();
for (Trade trade : trades) {
@ -178,7 +182,7 @@ public class TradeManager {
trade.updateDepositTxFromWallet(tradeWalletService);
initTrade(trade);
// after we are authenticated we remove mailbox messages.
// after network is ready we remove mailbox messages.
DecryptedMsgWithPubKey mailboxMessage = trade.getMailboxMessage();
if (mailboxMessage != null) {
log.trace("initPendingTrades/removeEntryFromMailbox mailboxMessage = " + mailboxMessage);

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

@ -24,8 +24,8 @@ import io.bitsquare.common.UserThread;
import io.bitsquare.common.crypto.KeyRing;
import io.bitsquare.common.handlers.ErrorMessageHandler;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.p2p.FirstPeerAuthenticatedListener;
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;
@ -67,7 +67,7 @@ public class OpenOfferManager {
private final TradableList<OpenOffer> openOffers;
private final Storage<TradableList<OpenOffer>> openOffersStorage;
private boolean shutDownRequested;
private FirstPeerAuthenticatedListener firstPeerAuthenticatedListener;
private NetWorkReadyListener netWorkReadyListener;
private final Timer timer = new Timer();
///////////////////////////////////////////////////////////////////////////////////////////
@ -103,12 +103,12 @@ public class OpenOfferManager {
"OpenOfferManager.ShutDownHook"));
// Handler for incoming offer availability requests
p2PService.addDecryptedMailListener((decryptedMessageWithPubKey, peerAddress) -> {
p2PService.addDecryptedMailListener((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;
if (message instanceof OfferAvailabilityRequest)
handleOfferAvailabilityRequest((OfferAvailabilityRequest) message, peerAddress);
handleOfferAvailabilityRequest((OfferAvailabilityRequest) message, peersNodeAddress);
});
}
@ -126,14 +126,14 @@ public class OpenOfferManager {
// Before the TTL is reached we re-publish our offers
// If offer removal at shutdown fails we don't want to have long term dangling dead offers, so we set
// TTL quite short and use re-publish as strategy. Offerers need to be online anyway.
if (!p2PService.isAuthenticated()) {
firstPeerAuthenticatedListener = new FirstPeerAuthenticatedListener() {
if (!p2PService.isNetworkReady()) {
netWorkReadyListener = new NetWorkReadyListener() {
@Override
public void onFirstPeerAuthenticated() {
public void onBootstrapped() {
startRePublishThread();
}
};
p2PService.addP2PServiceListener(firstPeerAuthenticatedListener);
p2PService.addP2PServiceListener(netWorkReadyListener);
} else {
startRePublishThread();
@ -141,8 +141,8 @@ public class OpenOfferManager {
}
private void startRePublishThread() {
if (firstPeerAuthenticatedListener != null)
p2PService.removeP2PServiceListener(firstPeerAuthenticatedListener);
if (netWorkReadyListener != null)
p2PService.removeP2PServiceListener(netWorkReadyListener);
long period = (long) (Offer.TTL * 0.8); // republish sufficiently before offer would expire
TimerTask timerTask = new TimerTask() {

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

@ -56,14 +56,14 @@ public class OfferAvailabilityProtocol {
this.resultHandler = resultHandler;
this.errorMessageHandler = errorMessageHandler;
decryptedMailListener = (decryptedMessageWithPubKey, peerAddress) -> {
decryptedMailListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
Message message = decryptedMessageWithPubKey.message;
if (message instanceof OfferMessage) {
OfferMessage offerMessage = (OfferMessage) message;
nonEmptyStringOf(offerMessage.offerId);
if (message instanceof OfferAvailabilityResponse
&& model.offer.getId().equals(offerMessage.offerId)) {
log.trace("handle OfferAvailabilityResponse = " + message.getClass().getSimpleName() + " from " + peerAddress);
log.trace("handle OfferAvailabilityResponse = " + message.getClass().getSimpleName() + " from " + peersNodeAddress);
handle((OfferAvailabilityResponse) message);
}
}

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

@ -49,19 +49,19 @@ public abstract class TradeProtocol {
this.trade = trade;
this.processModel = trade.getProcessModel();
decryptedMailListener = (decryptedMessageWithPubKey, peerAddress) -> {
decryptedMailListener = (decryptedMessageWithPubKey, peersNodeAddress) -> {
// We check the sig only as soon we have stored the peers pubKeyRing.
PubKeyRing tradingPeerPubKeyRing = processModel.tradingPeer.getPubKeyRing();
PublicKey signaturePubKey = decryptedMessageWithPubKey.signaturePubKey;
if (tradingPeerPubKeyRing != null && signaturePubKey.equals(tradingPeerPubKeyRing.getSignaturePubKey())) {
Message message = decryptedMessageWithPubKey.message;
log.trace("handleNewMessage: message = " + message.getClass().getSimpleName() + " from " + peerAddress);
log.trace("handleNewMessage: message = " + message.getClass().getSimpleName() + " from " + peersNodeAddress);
if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(processModel.getId())) {
doHandleDecryptedMessage(tradeMessage, peerAddress);
doHandleDecryptedMessage(tradeMessage, peersNodeAddress);
}
}
} else {