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

fix concurrency issues by synchronizing on base persistable list

Browse source
This commit is contained in:
woodser 2025-04-06 17:43:23 -04:00 • committed by woodser
parent 3c6914ac7e
commit 9027ce6634
15 changed files with 262 additions and 220 deletions
Download patch file Download diff file Expand all files Collapse all files

65
core/src/main/java/haveno/core/offer/OpenOfferManager.java
View file

@ -35,6 +35,8 @@
package haveno.core.offer;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableList;
import com.google.inject.Inject;
import haveno.common.ThreadUtils;
import haveno.common.Timer;
@ -261,7 +263,10 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
private void cleanUpAddressEntries() {
Set<String> openOffersIdSet = openOffers.getList().stream().map(OpenOffer::getId).collect(Collectors.toSet());
Set<String> openOffersIdSet;
synchronized (openOffers.getList()) {
openOffersIdSet = openOffers.getList().stream().map(OpenOffer::getId).collect(Collectors.toSet());
}
xmrWalletService.getAddressEntriesForOpenOffer().stream()
.filter(e -> !openOffersIdSet.contains(e.getOfferId()))
.forEach(e -> {
@ -292,7 +297,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
ThreadUtils.execute(() -> {
// remove offers from offer book
synchronized (openOffers) {
synchronized (openOffers.getList()) {
openOffers.forEach(openOffer -> {
if (openOffer.getState() == OpenOffer.State.AVAILABLE) {
offerBookService.removeOfferAtShutDown(openOffer.getOffer().getOfferPayload());
@ -334,6 +339,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
private void removeOpenOffers(List<OpenOffer> openOffers, @Nullable Runnable completeHandler) {
synchronized (openOffers) {
int size = openOffers.size();
// Copy list as we remove in the loop
List<OpenOffer> openOffersList = new ArrayList<>(openOffers);
@ -344,6 +350,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
if (completeHandler != null)
UserThread.runAfter(completeHandler, size * 200 + 500, TimeUnit.MILLISECONDS);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
@ -450,14 +457,18 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
});
// poll spent status of open offer key images
for (OpenOffer openOffer : getOpenOffers()) {
synchronized (openOffers.getList()) {
for (OpenOffer openOffer : openOffers.getList()) {
xmrConnectionService.getKeyImagePoller().addKeyImages(openOffer.getOffer().getOfferPayload().getReserveTxKeyImages(), OPEN_OFFER_GROUP_KEY_IMAGE_ID);
}
}
// poll spent status of signed offer key images
synchronized (signedOffers.getList()) {
for (SignedOffer signedOffer : signedOffers.getList()) {
xmrConnectionService.getKeyImagePoller().addKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
}
}
}, THREAD_ID);
});
}
@ -858,7 +869,6 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
public boolean hasAvailableOpenOffers() {
synchronized (openOffers) {
for (OpenOffer openOffer : getOpenOffers()) {
if (openOffer.getState() == OpenOffer.State.AVAILABLE) {
return true;
@ -866,22 +876,19 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
return false;
}
}
public List<OpenOffer> getOpenOffers() {
synchronized (openOffers) {
return new ArrayList<>(getObservableList());
synchronized (openOffers.getList()) {
return ImmutableList.copyOf(getObservableList());
}
}
public List<OpenOffer> getOpenOfferGroup(String groupId) {
if (groupId == null) throw new IllegalArgumentException("groupId cannot be null");
synchronized (openOffers) {
return getOpenOffers().stream()
.filter(openOffer -> groupId.equals(openOffer.getGroupId()))
.collect(Collectors.toList());
}
}
public boolean hasClonedOffer(String offerId) {
OpenOffer openOffer = getOpenOffer(offerId).orElse(null);
@ -890,7 +897,6 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
public boolean hasClonedOffers() {
synchronized (openOffers) {
for (OpenOffer openOffer : getOpenOffers()) {
if (getOpenOfferGroup(openOffer.getGroupId()).size() > 1) {
return true;
@ -898,16 +904,15 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
return false;
}
}
public List<SignedOffer> getSignedOffers() {
synchronized (signedOffers) {
return new ArrayList<>(signedOffers.getObservableList());
synchronized (signedOffers.getList()) {
return ImmutableList.copyOf(signedOffers.getObservableList());
}
}
public ObservableList<SignedOffer> getObservableSignedOffersList() {
synchronized (signedOffers) {
synchronized (signedOffers.getList()) {
return signedOffers.getObservableList();
}
}
@ -917,9 +922,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
public Optional<OpenOffer> getOpenOffer(String offerId) {
synchronized (openOffers) {
return openOffers.stream().filter(e -> e.getId().equals(offerId)).findFirst();
}
return getOpenOffers().stream().filter(e -> e.getId().equals(offerId)).findFirst();
}
public boolean hasOpenOffer(String offerId) {
@ -927,14 +930,12 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
public Optional<SignedOffer> getSignedOfferById(String offerId) {
synchronized (signedOffers) {
return signedOffers.stream().filter(e -> e.getOfferId().equals(offerId)).findFirst();
}
return getSignedOffers().stream().filter(e -> e.getOfferId().equals(offerId)).findFirst();
}
private void addOpenOffer(OpenOffer openOffer) {
log.info("Adding open offer {}", openOffer.getId());
synchronized (openOffers) {
synchronized (openOffers.getList()) {
openOffers.add(openOffer);
}
if (openOffer.getOffer().getOfferPayload().getReserveTxKeyImages() != null) {
@ -944,7 +945,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
private void removeOpenOffer(OpenOffer openOffer) {
log.info("Removing open offer {}", openOffer.getId());
synchronized (openOffers) {
synchronized (openOffers.getList()) {
openOffers.remove(openOffer);
}
synchronized (placeOfferProtocols) {
@ -957,17 +958,19 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
}
private void cancelOpenOffersOnSpent(String keyImage) {
for (OpenOffer openOffer : getOpenOffers()) {
synchronized (openOffers.getList()) {
for (OpenOffer openOffer : openOffers.getList()) {
if (openOffer.getOffer().getOfferPayload().getReserveTxKeyImages() != null && openOffer.getOffer().getOfferPayload().getReserveTxKeyImages().contains(keyImage)) {
log.warn("Canceling open offer because reserved funds have been spent, offerId={}, state={}", openOffer.getId(), openOffer.getState());
cancelOpenOffer(openOffer, null, null);
}
}
}
}
private void addSignedOffer(SignedOffer signedOffer) {
log.info("Adding SignedOffer for offer {}", signedOffer.getOfferId());
synchronized (signedOffers) {
synchronized (signedOffers.getList()) {
// remove signed offers with common key images
for (String keyImage : signedOffer.getReserveTxKeyImages()) {
@ -982,19 +985,21 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
private void removeSignedOffer(SignedOffer signedOffer) {
log.info("Removing SignedOffer for offer {}", signedOffer.getOfferId());
synchronized (signedOffers) {
synchronized (signedOffers.getList()) {
signedOffers.remove(signedOffer);
xmrConnectionService.getKeyImagePoller().removeKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
}
xmrConnectionService.getKeyImagePoller().removeKeyImages(signedOffer.getReserveTxKeyImages(), SIGNED_OFFER_KEY_IMAGE_GROUP_ID);
}
private void removeSignedOffers(String keyImage) {
for (SignedOffer signedOffer : new ArrayList<SignedOffer>(signedOffers.getList())) {
synchronized (signedOffers.getList()) {
for (SignedOffer signedOffer : getSignedOffers()) {
if (signedOffer.getReserveTxKeyImages().contains(keyImage)) {
removeSignedOffer(signedOffer);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Place offer helpers
@ -2070,7 +2075,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
OpenOffer openOffer = list.remove(0);
boolean contained = false;
synchronized (openOffers) {
synchronized (openOffers.getList()) {
contained = openOffers.contains(openOffer);
}
if (contained) {
@ -2171,7 +2176,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
if (periodicRefreshOffersTimer == null)
periodicRefreshOffersTimer = UserThread.runPeriodically(() -> {
if (!stopped) {
synchronized (openOffers) {
synchronized (openOffers.getList()) {
int size = openOffers.size();
//we clone our list as openOffers might change during our delayed call
final ArrayList<OpenOffer> openOffersList = new ArrayList<>(openOffers.getList());
@ -2186,7 +2191,7 @@ public class OpenOfferManager implements PeerManager.Listener, DecryptedDirectMe
UserThread.runAfterRandomDelay(() -> {
// we need to check if in the meantime the offer has been removed
boolean contained = false;
synchronized (openOffers) {
synchronized (openOffers.getList()) {
contained = openOffers.contains(openOffer);
}
if (contained) maybeRefreshOffer(openOffer, 0, 1);

2
core/src/main/java/haveno/core/offer/SignedOfferList.java
View file

@ -47,11 +47,13 @@ public final class SignedOfferList extends PersistableListAsObservable<SignedOff
@Override
public Message toProtoMessage() {
synchronized (getList()) {
return protobuf.PersistableEnvelope.newBuilder()
.setSignedOfferList(protobuf.SignedOfferList.newBuilder()
.addAllSignedOffer(ProtoUtil.collectionToProto(getList(), protobuf.SignedOffer.class)))
.build();
}
}
public static SignedOfferList fromProto(protobuf.SignedOfferList proto) {
List<SignedOffer> list = proto.getSignedOfferList().stream()

2
core/src/main/java/haveno/core/payment/PaymentAccountList.java
View file

@ -36,11 +36,13 @@ public class PaymentAccountList extends PersistableList<PaymentAccount> {
@Override
public Message toProtoMessage() {
synchronized (getList()) {
return protobuf.PersistableEnvelope.newBuilder()
.setPaymentAccountList(protobuf.PaymentAccountList.newBuilder()
.addAllPaymentAccount(getList().stream().map(PaymentAccount::toProtoMessage).collect(Collectors.toList())))
.build();
}
}
public static PaymentAccountList fromProto(protobuf.PaymentAccountList proto, CoreProtoResolver coreProtoResolver) {
return new PaymentAccountList(new ArrayList<>(proto.getPaymentAccountList().stream()

6
core/src/main/java/haveno/core/support/dispute/DisputeListService.java
View file

@ -74,7 +74,9 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
@Override
public void readPersisted(Runnable completeHandler) {
persistenceManager.readPersisted(getFileName(), persisted -> {
synchronized (persisted.getList()) {
disputeList.setAll(persisted.getList());
}
completeHandler.run();
},
completeHandler);
@ -145,10 +147,13 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
private void onDisputesChangeListener(List<? extends Dispute> addedList,
@Nullable List<? extends Dispute> removedList) {
if (removedList != null) {
synchronized (removedList) {
removedList.forEach(dispute -> {
disputedTradeIds.remove(dispute.getTradeId());
});
}
}
synchronized (addedList) {
addedList.forEach(dispute -> {
// for each dispute added, keep track of its "BadgeCountProperty"
EasyBind.subscribe(dispute.getBadgeCountProperty(),
@ -166,6 +171,7 @@ public abstract class DisputeListService<T extends DisputeList<Dispute>> impleme
disputedTradeIds.add(dispute.getTradeId());
});
}
}
public void requestPersistence() {
persistenceManager.requestPersistence();

4
core/src/main/java/haveno/core/support/dispute/DisputeManager.java
View file

@ -288,6 +288,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
cleanupDisputes();
List<Dispute> disputes = getDisputeList().getList();
synchronized (disputes) {
disputes.forEach(dispute -> {
try {
DisputeValidation.validateNodeAddresses(dispute, config);
@ -296,6 +297,7 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
validationExceptions.add(e);
}
});
}
maybeClearSensitiveData();
}
@ -318,12 +320,14 @@ public abstract class DisputeManager<T extends DisputeList<Dispute>> extends Sup
public void maybeClearSensitiveData() {
log.info("{} checking closed disputes eligibility for having sensitive data cleared", super.getClass().getSimpleName());
Instant safeDate = closedTradableManager.getSafeDateForSensitiveDataClearing();
synchronized (getDisputeList().getList()) {
getDisputeList().getList().stream()
.filter(e -> e.isClosed())
.filter(e -> e.getOpeningDate().toInstant().isBefore(safeDate))
.forEach(Dispute::maybeClearSensitiveData);
requestPersistence();
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Dispute handling

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

@ -176,6 +176,7 @@ public final class ArbitrationManager extends DisputeManager<ArbitrationDisputeL
// remove disputes opened by arbitrator, which is not allowed
Set<Dispute> toRemoves = new HashSet<>();
List<Dispute> disputes = getDisputeList().getList();
synchronized (disputes) {
for (Dispute dispute : disputes) {
// get dispute's trade
@ -190,6 +191,7 @@ public final class ArbitrationManager extends DisputeManager<ArbitrationDisputeL
toRemoves.add(dispute);
}
}
}
for (Dispute toRemove : toRemoves) {
log.warn("Removing invalid dispute opened by arbitrator, disputeId={}", toRemove.getTradeId(), toRemove.getId());
getDisputeList().remove(toRemove);

2
core/src/main/java/haveno/core/support/dispute/mediation/MediationDisputeList.java
View file

@ -55,9 +55,11 @@ public final class MediationDisputeList extends DisputeList<Dispute> {
@Override
public Message toProtoMessage() {
synchronized (getList()) {
return protobuf.PersistableEnvelope.newBuilder().setMediationDisputeList(protobuf.MediationDisputeList.newBuilder()
.addAllDispute(ProtoUtil.collectionToProto(getList(), protobuf.Dispute.class))).build();
}
}
public static MediationDisputeList fromProto(protobuf.MediationDisputeList proto,
CoreProtoResolver coreProtoResolver) {

3
core/src/main/java/haveno/core/support/dispute/refund/RefundDisputeList.java
View file

@ -58,10 +58,11 @@ public final class RefundDisputeList extends DisputeList<Dispute> {
@Override
public Message toProtoMessage() {
forEach(dispute -> checkArgument(dispute.getSupportType().equals(SupportType.REFUND), "Support type has to be REFUND"));
synchronized (getList()) {
return protobuf.PersistableEnvelope.newBuilder().setRefundDisputeList(protobuf.RefundDisputeList.newBuilder()
.addAllDispute(ProtoUtil.collectionToProto(getList(), protobuf.Dispute.class))).build();
}
}
public static RefundDisputeList fromProto(protobuf.RefundDisputeList proto,
CoreProtoResolver coreProtoResolver) {

2
core/src/main/java/haveno/core/trade/CleanupMailboxMessages.java
View file

@ -55,6 +55,7 @@ public class CleanupMailboxMessages {
}
public void handleTrades(List<Trade> trades) {
synchronized (trades) {
// We wrap in a try catch as in failed trades we cannot be sure if expected data is set, so we could get
// a NullPointer and do not want that this escalate to the user.
try {
@ -72,6 +73,7 @@ public class CleanupMailboxMessages {
log.error("Cleanup mailbox messages failed. {}", t.toString());
}
}
}
private void cleanupMailboxMessages(List<Trade> trades) {
mailboxMessageService.getMyDecryptedMailboxMessages()

26
core/src/main/java/haveno/core/trade/ClosedTradableManager.java
View file

@ -81,10 +81,12 @@ public class ClosedTradableManager implements PersistedDataHost {
@Override
public void readPersisted(Runnable completeHandler) {
persistenceManager.readPersisted(persisted -> {
synchronized (persisted.getList()) {
closedTradables.setAll(persisted.getList());
closedTradables.stream()
.filter(tradable -> tradable.getOffer() != null)
.forEach(tradable -> tradable.getOffer().setPriceFeedService(priceFeedService));
}
completeHandler.run();
},
completeHandler);
@ -96,7 +98,7 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public void add(Tradable tradable) {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
if (closedTradables.add(tradable)) {
maybeClearSensitiveData();
requestPersistence();
@ -105,7 +107,7 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public void remove(Tradable tradable) {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
if (closedTradables.remove(tradable)) {
requestPersistence();
}
@ -117,17 +119,17 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public ObservableList<Tradable> getObservableList() {
synchronized (closedTradables) {
return closedTradables.getObservableList();
}
}
public List<Tradable> getTradableList() {
synchronized (closedTradables.getList()) {
return ImmutableList.copyOf(new ArrayList<>(getObservableList()));
}
}
public List<Trade> getClosedTrades() {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
return ImmutableList.copyOf(getObservableList().stream()
.filter(e -> e instanceof Trade)
.map(e -> (Trade) e)
@ -136,7 +138,7 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public List<OpenOffer> getCanceledOpenOffers() {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
return ImmutableList.copyOf(getObservableList().stream()
.filter(e -> (e instanceof OpenOffer) && ((OpenOffer) e).getState().equals(CANCELED))
.map(e -> (OpenOffer) e)
@ -145,19 +147,19 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public Optional<Tradable> getTradableById(String id) {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
return closedTradables.stream().filter(e -> e.getId().equals(id)).findFirst();
}
}
public Optional<Trade> getTradeById(String id) {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
return getClosedTrades().stream().filter(e -> e.getId().equals(id)).findFirst();
}
}
public void maybeClearSensitiveData() {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
log.info("checking closed trades eligibility for having sensitive data cleared");
closedTradables.stream()
.filter(e -> e instanceof Trade)
@ -170,7 +172,7 @@ public class ClosedTradableManager implements PersistedDataHost {
public boolean canTradeHaveSensitiveDataCleared(String tradeId) {
Instant safeDate = getSafeDateForSensitiveDataClearing();
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
return closedTradables.stream()
.filter(e -> e.getId().equals(tradeId))
.filter(e -> e.getDate().toInstant().isBefore(safeDate))
@ -205,10 +207,12 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public BigInteger getTotalTradeFee(List<Tradable> tradableList) {
synchronized (tradableList) {
return BigInteger.valueOf(tradableList.stream()
.mapToLong(tradable -> getTradeFee(tradable).longValueExact())
.sum());
}
}
private BigInteger getTradeFee(Tradable tradable) {
return getXmrTradeFee(tradable);
@ -229,7 +233,7 @@ public class ClosedTradableManager implements PersistedDataHost {
}
public void removeTrade(Trade trade) {
synchronized (closedTradables) {
synchronized (closedTradables.getList()) {
if (closedTradables.remove(trade)) {
requestPersistence();
}

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

@ -269,10 +269,12 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
@Override
public void readPersisted(Runnable completeHandler) {
persistenceManager.readPersisted(persisted -> {
synchronized (persisted.getList()) {
tradableList.setAll(persisted.getList());
tradableList.stream()
.filter(trade -> trade.getOffer() != null)
.forEach(trade -> trade.getOffer().setPriceFeedService(priceFeedService));
}
completeHandler.run();
},
completeHandler);
@ -992,7 +994,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
log.info("TradeManager.removeTrade() " + trade.getId());
// remove trade
synchronized (tradableList) {
synchronized (tradableList.getList()) {
if (!tradableList.remove(trade)) return;
}
@ -1036,7 +1038,8 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
private void updateTradePeriodState() {
if (isShutDownStarted) return;
for (Trade trade : new ArrayList<Trade>(tradableList.getList())) {
synchronized (tradableList.getList()) {
for (Trade trade : tradableList.getList()) {
if (!trade.isPayoutPublished()) {
Date maxTradePeriodDate = trade.getMaxTradePeriodDate();
Date halfTradePeriodDate = trade.getHalfTradePeriodDate();
@ -1053,6 +1056,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
@ -1093,7 +1097,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
public Stream<Trade> getTradesStreamWithFundsLockedIn() {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return getObservableList().stream().filter(Trade::isFundsLockedIn);
}
}
@ -1108,7 +1112,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
public Set<String> getSetOfFailedOrClosedTradeIdsFromLockedInFunds() throws TradeTxException {
AtomicReference<TradeTxException> tradeTxException = new AtomicReference<>();
synchronized (tradableList) {
synchronized (tradableList.getList()) {
Set<String> tradesIdSet = getTradesStreamWithFundsLockedIn()
.filter(Trade::hasFailed)
.map(Trade::getId)
@ -1170,7 +1174,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
initPersistedTrade(trade);
UserThread.execute(() -> {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
if (!tradableList.contains(trade)) {
tradableList.add(trade);
}
@ -1241,7 +1245,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
public ObservableList<Trade> getObservableList() {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return tradableList.getObservableList();
}
}
@ -1274,33 +1278,33 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
public Optional<Trade> getOpenTrade(String tradeId) {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return tradableList.stream().filter(e -> e.getId().equals(tradeId)).findFirst();
}
}
public boolean hasOpenTrade(Trade trade) {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return tradableList.contains(trade);
}
}
public boolean hasFailedScheduledTrade(String offerId) {
synchronized (failedTradesManager) {
return failedTradesManager.getTradeById(offerId).isPresent() && failedTradesManager.getTradeById(offerId).get().isProtocolErrorHandlingScheduled();
}
}
public Optional<Trade> getOpenTradeByUid(String tradeUid) {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return tradableList.stream().filter(e -> e.getUid().equals(tradeUid)).findFirst();
}
}
public List<Trade> getAllTrades() {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
List<Trade> trades = new ArrayList<Trade>();
synchronized (tradableList.getList()) {
trades.addAll(tradableList.getList());
}
trades.addAll(closedTradableManager.getClosedTrades());
trades.addAll(failedTradesManager.getObservableList());
return trades;
@ -1308,7 +1312,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
public List<Trade> getOpenTrades() {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
return ImmutableList.copyOf(getObservableList().stream()
.filter(e -> e instanceof Trade)
.map(e -> e)
@ -1329,7 +1333,7 @@ public class TradeManager implements PersistedDataHost, DecryptedDirectMessageLi
}
private void addTrade(Trade trade) {
synchronized (tradableList) {
synchronized (tradableList.getList()) {
if (tradableList.add(trade)) {
requestPersistence();
}

14
core/src/main/java/haveno/core/trade/failed/FailedTradesManager.java
View file

@ -70,10 +70,12 @@ public class FailedTradesManager implements PersistedDataHost {
@Override
public void readPersisted(Runnable completeHandler) {
persistenceManager.readPersisted(persisted -> {
synchronized (persisted.getList()) {
failedTrades.setAll(persisted.getList());
failedTrades.stream()
.filter(trade -> trade.getOffer() != null)
.forEach(trade -> trade.getOffer().setPriceFeedService(priceFeedService));
}
completeHandler.run();
},
completeHandler);
@ -84,7 +86,7 @@ public class FailedTradesManager implements PersistedDataHost {
}
public void add(Trade trade) {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
if (failedTrades.add(trade)) {
requestPersistence();
}
@ -92,7 +94,7 @@ public class FailedTradesManager implements PersistedDataHost {
}
public void removeTrade(Trade trade) {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
if (failedTrades.remove(trade)) {
requestPersistence();
}
@ -104,26 +106,26 @@ public class FailedTradesManager implements PersistedDataHost {
}
public ObservableList<Trade> getObservableList() {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
return failedTrades.getObservableList();
}
}
public Optional<Trade> getTradeById(String id) {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
return failedTrades.stream().filter(e -> e.getId().equals(id)).findFirst();
}
}
public Stream<Trade> getTradesStreamWithFundsLockedIn() {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
return failedTrades.stream()
.filter(Trade::isFundsLockedIn);
}
}
public void unFailTrade(Trade trade) {
synchronized (failedTrades) {
synchronized (failedTrades.getList()) {
if (unFailTradeCallback == null)
return;

2
desktop/src/main/java/haveno/desktop/main/offer/signedoffer/SignedOffersDataModel.java
View file

@ -62,7 +62,9 @@ class SignedOffersDataModel extends ActivatableDataModel {
private void applyList() {
list.clear();
synchronized (openOfferManager.getObservableSignedOffersList()) {
list.addAll(openOfferManager.getObservableSignedOffersList().stream().map(SignedOfferListItem::new).collect(Collectors.toList()));
}
// we sort by date, the earliest first
list.sort((o1, o2) -> new Date(o2.getSignedOffer().getTimeStamp()).compareTo(new Date(o1.getSignedOffer().getTimeStamp())));

2
desktop/src/main/java/haveno/desktop/util/GUIUtil.java
View file

@ -206,6 +206,7 @@ public class GUIUtil {
persistenceManager.readPersisted(fileName, persisted -> {
StringBuilder msg = new StringBuilder();
HashSet<PaymentAccount> paymentAccounts = new HashSet<>();
synchronized (persisted.getList()) {
persisted.getList().forEach(paymentAccount -> {
String id = paymentAccount.getId();
if (user.getPaymentAccount(id) == null) {
@ -215,6 +216,7 @@ public class GUIUtil {
msg.append(Res.get("guiUtil.accountImport.noImport", id));
}
});
}
user.addImportedPaymentAccounts(paymentAccounts);
new Popup().feedback(Res.get("guiUtil.accountImport.imported", path, msg)).show();
},

2
p2p/src/main/java/haveno/network/p2p/mailbox/MailboxMessageList.java
View file

@ -48,6 +48,7 @@ public class MailboxMessageList extends PersistableList<MailboxItem> {
@Override
public Message toProtoMessage() {
synchronized (getList()) {
return protobuf.PersistableEnvelope.newBuilder()
.setMailboxMessageList(protobuf.MailboxMessageList.newBuilder()
.addAllMailboxItem(getList().stream()
@ -55,6 +56,7 @@ public class MailboxMessageList extends PersistableList<MailboxItem> {
.collect(Collectors.toList())))
.build();
}
}
public static MailboxMessageList fromProto(protobuf.MailboxMessageList proto,
NetworkProtoResolver networkProtoResolver) {