public Property status() { return new Property("status", null, ctx.getNetworkHandler().getNetworkStatus() ); }
public void startup() { ctx.getNetworkHandler().start(); }
public void shutdown() { ctx.getNetworkHandler().stop(); }
private void receiveMessage(ObjectMessage objectMessage) { requestedObjects.remove(objectMessage.getInventoryVector()); if (ctx.getInventory().contains(objectMessage)) { LOG.trace("Received object " + objectMessage.getInventoryVector() + " - already in inventory"); return; } try { listener.receive(objectMessage); cryptography().checkProofOfWork(objectMessage, NETWORK_NONCE_TRIALS_PER_BYTE, NETWORK_EXTRA_BYTES); ctx.getInventory().storeObject(objectMessage); // offer object to some random nodes so it gets distributed throughout the network: ctx.getNetworkHandler().offer(objectMessage.getInventoryVector()); lastObjectTime = UnixTime.now(); } catch (InsufficientProofOfWorkException e) { LOG.warn(e.getMessage()); // DebugUtils.saveToFile(objectMessage); // this line must not be committed active } catch (IOException e) { LOG.error("Stream " + objectMessage.getStream() + ", object type " + objectMessage.getType() + ": " + e.getMessage(), e); } finally { if (commonRequestedObjects.remove(objectMessage.getInventoryVector()) == null) { LOG.debug("Received object that wasn't requested."); } } }
/** * Send a custom message to a specific node (that should implement handling for this message type) and returns * the response, which in turn is expected to be a {@link CustomMessage}. * * @param server the node's address * @param port the node's port * @param request the request * @return the response */ public CustomMessage send(InetAddress server, int port, CustomMessage request) { return ctx.getNetworkHandler().send(server, port, request); }
public void disconnect() { state = DISCONNECTED; // Make sure objects that are still missing are requested from other nodes ctx.getNetworkHandler().request(requestedObjects); }
public boolean isRunning() { return ctx.getNetworkHandler().isRunning(); }
/** * @param host a trusted node that must be reliable (it's used for every synchronization) * @param port of the trusted host, default is 8444 * @param timeoutInSeconds synchronization should end no later than about 5 seconds after the timeout elapsed, even * if not all objects were fetched * @param wait waits for the synchronization thread to finish */ public void synchronize(InetAddress host, int port, long timeoutInSeconds, boolean wait) { Future<?> future = ctx.getNetworkHandler().synchronize(host, port, timeoutInSeconds); if (wait) { try { future.get(); } catch (InterruptedException e) { LOG.info("Thread was interrupted. Trying to shut down synchronization and returning."); future.cancel(true); } catch (CancellationException | ExecutionException e) { LOG.debug(e.getMessage(), e); } } }
public void requestPubkey(BitmessageAddress contact) { long expires = UnixTime.now(+2 * DAY); LOG.info("Expires at " + expires); ObjectMessage response = new ObjectMessage.Builder() .stream(contact.getStream()) .expiresTime(expires) .payload(new GetPubkey(contact)) .build(); Security.doProofOfWork(response, proofOfWorkEngine, networkNonceTrialsPerByte, networkExtraBytes); inventory.storeObject(response); networkHandler.offer(response.getInventoryVector()); }
private void send(long stream, ObjectPayload payload, long timeToLive) { long expires = UnixTime.now(+timeToLive); LOG.info("Expires at " + expires); ObjectMessage object = new ObjectMessage.Builder() .stream(stream) .expiresTime(expires) .payload(payload) .build(); Security.doProofOfWork(object, ctx.getProofOfWorkEngine(), ctx.getNetworkNonceTrialsPerByte(), ctx.getNetworkExtraBytes()); ctx.getInventory().storeObject(object); ctx.getNetworkHandler().offer(object.getInventoryVector()); }
public void shutdown() { ctx.getNetworkHandler().stop(); }
public Property status() { return new Property("status", null, ctx.getNetworkHandler().getNetworkStatus(), new Property("unacknowledged", ctx.getMessageRepository().findMessagesToResend().size()) ); }
public void startup(Listener listener) { this.listener = listener; ctx.getNetworkHandler().start(new DefaultMessageListener(ctx, listener)); }
public void send(BitmessageAddress from, BitmessageAddress to, ObjectPayload payload, long timeToLive, long nonceTrialsPerByte, long extraBytes) { try { if (to == null) to = from; long expires = UnixTime.now(+timeToLive); LOG.info("Expires at " + expires); ObjectMessage object = new ObjectMessage.Builder() .stream(to.getStream()) .expiresTime(expires) .payload(payload) .build(); if (object.isSigned()) { object.sign(from.getPrivateKey()); } if (payload instanceof Broadcast) { ((Broadcast) payload).encrypt(); } else if (payload instanceof Encrypted) { object.encrypt(to.getPubkey()); } Security.doProofOfWork(object, proofOfWorkEngine, nonceTrialsPerByte, extraBytes); if (payload instanceof PlaintextHolder) { Plaintext plaintext = ((PlaintextHolder) payload).getPlaintext(); plaintext.setInventoryVector(object.getInventoryVector()); messageRepository.save(plaintext); } inventory.storeObject(object); networkHandler.offer(object.getInventoryVector()); } catch (IOException e) { throw new RuntimeException(e); } }
public void sendPubkey(BitmessageAddress identity, long targetStream) { try { long expires = UnixTime.now(+28 * DAY); LOG.info("Expires at " + expires); ObjectMessage response = new ObjectMessage.Builder() .stream(targetStream) .expiresTime(expires) .payload(identity.getPubkey()) .build(); response.sign(identity.getPrivateKey()); response.encrypt(Security.createPublicKey(identity.getPublicDecryptionKey()).getEncoded(false)); Security.doProofOfWork(response, proofOfWorkEngine, networkNonceTrialsPerByte, networkExtraBytes); if (response.isSigned()) { response.sign(identity.getPrivateKey()); } if (response instanceof Encrypted) { response.encrypt(Security.createPublicKey(identity.getPublicDecryptionKey()).getEncoded(false)); } inventory.storeObject(response); networkHandler.offer(response.getInventoryVector()); // TODO: save that the pubkey was just sent, and on which stream! } catch (IOException e) { throw new RuntimeException(e); } }
protected void receive(InventoryVector iv, Plaintext msg) { msg.setInventoryVector(iv); labeler.setLabels(msg); ctx.getMessageRepository().save(msg); listener.receive(msg); updatePubkey(msg.getFrom(), msg.getFrom().getPubkey()); if (msg.getType() == Plaintext.Type.MSG && msg.getTo().has(Pubkey.Feature.DOES_ACK)) { ObjectMessage ack = msg.getAckMessage(); if (ack != null) { ctx.getInventory().storeObject(ack); ctx.getNetworkHandler().offer(ack.getInventoryVector()); } } } }
ctx.getNetworkHandler().offer(object.getInventoryVector()); } else { item.message.getAckMessage().setNonce(nonce);