Examples with Message io.bitsquare.p2p.Message used on opensource projects

Example 1 with Message

use of io.bitsquare.p2p.Message in project bitsquare by bitsquare.

the class TorNetworkNodeTest method testTorNodeAfterBothReady.

//@Test
public void testTorNodeAfterBothReady() throws InterruptedException, IOException {
    latch = new CountDownLatch(2);
    int port = 9001;
    TorNetworkNode node1 = new TorNetworkNode(port, new File("torNode_" + port));
    node1.start(new SetupListener() {

        @Override
        public void onTorNodeReady() {
            log.debug("onReadyForSendingMessages");
        }

        @Override
        public void onHiddenServicePublished() {
            log.debug("onReadyForReceivingMessages");
            latch.countDown();
        }

        @Override
        public void onSetupFailed(Throwable throwable) {
        }
    });
    int port2 = 9002;
    TorNetworkNode node2 = new TorNetworkNode(port2, new File("torNode_" + port));
    node2.start(new SetupListener() {

        @Override
        public void onTorNodeReady() {
            log.debug("onReadyForSendingMessages");
        }

        @Override
        public void onHiddenServicePublished() {
            log.debug("onReadyForReceivingMessages");
            latch.countDown();
        }

        @Override
        public void onSetupFailed(Throwable throwable) {
        }
    });
    latch.await();
    latch = new CountDownLatch(2);
    node2.addMessageListener(new MessageListener() {

        @Override
        public void onMessage(Message message, Connection connection) {
            log.debug("onMessage node2 " + message);
            latch.countDown();
        }
    });
    SettableFuture<Connection> future = node1.sendMessage(node2.getNodeAddress(), new MockPayload("msg1"));
    Futures.addCallback(future, new FutureCallback<Connection>() {

        @Override
        public void onSuccess(Connection connection) {
            log.debug("onSuccess ");
            latch.countDown();
        }

        @Override
        public void onFailure(@NotNull Throwable throwable) {
            log.debug("onFailure ");
        }
    });
    latch.await();
    latch = new CountDownLatch(2);
    node1.shutDown(() -> {
        latch.countDown();
    });
    node2.shutDown(() -> {
        latch.countDown();
    });
    latch.await();
}

Example 2 with Message

use of io.bitsquare.p2p.Message in project bitsquare by bitsquare.

the class OpenOfferManager method handleOfferAvailabilityRequest.

///////////////////////////////////////////////////////////////////////////////////////////
// Offer Availability
///////////////////////////////////////////////////////////////////////////////////////////
private void handleOfferAvailabilityRequest(OfferAvailabilityRequest message, NodeAddress sender) {
    log.trace("handleNewMessage: message = " + message.getClass().getSimpleName() + " from " + sender);
    if (!stopped) {
        try {
            nonEmptyStringOf(message.offerId);
            checkNotNull(message.getPubKeyRing());
        } catch (Throwable t) {
            log.warn("Invalid message " + message.toString());
            return;
        }
        Optional<OpenOffer> openOfferOptional = findOpenOffer(message.offerId);
        AvailabilityResult availabilityResult;
        if (openOfferOptional.isPresent()) {
            if (openOfferOptional.get().getState() == OpenOffer.State.AVAILABLE) {
                final Offer offer = openOfferOptional.get().getOffer();
                if (!preferences.getIgnoreTradersList().stream().filter(i -> i.equals(offer.getOffererNodeAddress().getHostNameWithoutPostFix())).findAny().isPresent()) {
                    availabilityResult = AvailabilityResult.AVAILABLE;
                    List<NodeAddress> acceptedArbitrators = user.getAcceptedArbitratorAddresses();
                    if (acceptedArbitrators != null && !acceptedArbitrators.isEmpty()) {
                        // We need to be backward compatible. takersTradePrice was not used before 0.4.9.
                        if (message.takersTradePrice > 0) {
                            // losses and therefore an outdated market price.
                            try {
                                offer.checkTradePriceTolerance(message.takersTradePrice);
                            } catch (TradePriceOutOfToleranceException e) {
                                log.warn("Trade price check failed because takers price is outside out tolerance.");
                                availabilityResult = AvailabilityResult.PRICE_OUT_OF_TOLERANCE;
                            } catch (MarketPriceNotAvailableException e) {
                                log.warn(e.getMessage());
                                availabilityResult = AvailabilityResult.MARKET_PRICE_NOT_AVAILABLE;
                            } catch (Throwable e) {
                                log.warn("Trade price check failed. " + e.getMessage());
                                availabilityResult = AvailabilityResult.UNKNOWN_FAILURE;
                            }
                        }
                    } else {
                        log.warn("acceptedArbitrators is null or empty: acceptedArbitrators=" + acceptedArbitrators);
                        availabilityResult = AvailabilityResult.NO_ARBITRATORS;
                    }
                } else {
                    availabilityResult = AvailabilityResult.USER_IGNORED;
                }
            } else {
                availabilityResult = AvailabilityResult.OFFER_TAKEN;
            }
        } else {
            log.warn("handleOfferAvailabilityRequest: openOffer not found. That should never happen.");
            availabilityResult = AvailabilityResult.OFFER_TAKEN;
        }
        try {
            p2PService.sendEncryptedDirectMessage(sender, message.getPubKeyRing(), new OfferAvailabilityResponse(message.offerId, availabilityResult), new SendDirectMessageListener() {

                @Override
                public void onArrived() {
                    log.trace("OfferAvailabilityResponse successfully arrived at peer");
                }

                @Override
                public void onFault() {
                    log.debug("Sending OfferAvailabilityResponse failed.");
                }
            });
        } catch (Throwable t) {
            t.printStackTrace();
            log.debug("Exception at handleRequestIsOfferAvailableMessage " + t.getMessage());
        }
    } else {
        log.debug("We have stopped already. We ignore that handleOfferAvailabilityRequest call.");
    }
}

Example 3 with Message

use of io.bitsquare.p2p.Message in project bitsquare by bitsquare.

the class PrivateNotificationManager method handleMessage.

private void handleMessage(DecryptedMsgWithPubKey decryptedMsgWithPubKey, NodeAddress senderNodeAddress) {
    this.decryptedMsgWithPubKey = decryptedMsgWithPubKey;
    Message message = decryptedMsgWithPubKey.message;
    if (message instanceof PrivateNotificationMessage) {
        PrivateNotificationMessage privateNotificationMessage = (PrivateNotificationMessage) message;
        log.trace("Received privateNotificationMessage: " + privateNotificationMessage);
        if (privateNotificationMessage.getSenderNodeAddress().equals(senderNodeAddress)) {
            final PrivateNotification privateNotification = privateNotificationMessage.privateNotification;
            if (verifySignature(privateNotification))
                privateNotificationMessageProperty.set(privateNotification);
        } else {
            log.warn("Peer address not matching for privateNotificationMessage");
        }
    }
}

Example 4 with Message

use of io.bitsquare.p2p.Message in project bitsquare by bitsquare.

the class DisputeManager method applyMessages.

private void applyMessages() {
    decryptedDirectMessageWithPubKeys.forEach(decryptedMessageWithPubKey -> {
        Message message = decryptedMessageWithPubKey.message;
        log.debug("decryptedDirectMessageWithPubKeys.message " + message);
        if (message instanceof DisputeMessage)
            dispatchMessage((DisputeMessage) message);
    });
    decryptedDirectMessageWithPubKeys.clear();
    decryptedMailboxMessageWithPubKeys.forEach(decryptedMessageWithPubKey -> {
        Message message = decryptedMessageWithPubKey.message;
        log.debug("decryptedMessageWithPubKey.message " + message);
        if (message instanceof DisputeMessage) {
            dispatchMessage((DisputeMessage) message);
            p2PService.removeEntryFromMailbox(decryptedMessageWithPubKey);
        }
    });
    decryptedMailboxMessageWithPubKeys.clear();
}

Example 5 with Message

use of io.bitsquare.p2p.Message in project bitsquare by bitsquare.

the class TorNetworkNodeTest method testTorNodeBeforeSecondReady.

@Test
public void testTorNodeBeforeSecondReady() throws InterruptedException, IOException {
    latch = new CountDownLatch(1);
    int port = 9001;
    TorNetworkNode node1 = new TorNetworkNode(port, new File("torNode_" + port));
    node1.start(new SetupListener() {

        @Override
        public void onTorNodeReady() {
            log.debug("onReadyForSendingMessages");
        }

        @Override
        public void onHiddenServicePublished() {
            log.debug("onReadyForReceivingMessages");
            latch.countDown();
        }

        @Override
        public void onSetupFailed(Throwable throwable) {
        }
    });
    latch.await();
    latch = new CountDownLatch(1);
    int port2 = 9002;
    TorNetworkNode node2 = new TorNetworkNode(port2, new File("torNode_" + port2));
    node2.start(new SetupListener() {

        @Override
        public void onTorNodeReady() {
            log.debug("onReadyForSendingMessages");
            latch.countDown();
        }

        @Override
        public void onHiddenServicePublished() {
            log.debug("onReadyForReceivingMessages");
        }

        @Override
        public void onSetupFailed(Throwable throwable) {
        }
    });
    latch.await();
    latch = new CountDownLatch(2);
    node1.addMessageListener(new MessageListener() {

        @Override
        public void onMessage(Message message, Connection connection) {
            log.debug("onMessage node1 " + message);
            latch.countDown();
        }
    });
    SettableFuture<Connection> future = node2.sendMessage(node1.getNodeAddress(), new MockPayload("msg1"));
    Futures.addCallback(future, new FutureCallback<Connection>() {

        @Override
        public void onSuccess(Connection connection) {
            log.debug("onSuccess ");
            latch.countDown();
        }

        @Override
        public void onFailure(@NotNull Throwable throwable) {
            log.debug("onFailure ");
        }
    });
    latch.await();
    latch = new CountDownLatch(2);
    node1.shutDown(() -> {
        latch.countDown();
    });
    node2.shutDown(() -> {
        latch.countDown();
    });
    latch.await();
}