/** * Remove an outstanding piece data request. * * @param piece_number * @param piece_offset * @param length */ public void removePieceRequest(int piece_number, int piece_offset, int length) { if (destroyed) return; DiskManagerReadRequest dmr = peer.getManager().getDiskManager().createReadRequest(piece_number, piece_offset, length); try { lock_mon.enter(); if (requests.contains(dmr)) { requests.remove(dmr); return; } if (loading_messages.contains(dmr)) { loading_messages.remove(dmr); return; } for (Iterator i = queued_messages.entrySet().iterator(); i.hasNext(); ) { Map.Entry entry = (Map.Entry) i.next(); if (entry.getValue().equals(dmr)) { // it's already been queued BTPiece msg = (BTPiece) entry.getKey(); if (outgoing_message_queue.removeMessage(msg, true)) { i.remove(); } break; // do manual listener notify } } } finally { lock_mon.exit(); } outgoing_message_queue.doListenerNotifications(); }
private void sendPendingHaves() { if (destroyed) { return; } try { pending_haves_mon.enter(); int num_haves = pending_haves.size(); if (num_haves == 0) { return; } // single have -> use BT if (num_haves == 1 || az_have_version < BTMessageFactory.MESSAGE_VERSION_SUPPORTS_PADDING) { for (int i = 0; i < num_haves; i++) { Integer piece_num = (Integer) pending_haves.get(i); outgoing_message_q.addMessage(new BTHave(piece_num.intValue(), bt_have_version), true); } } else { int[] piece_numbers = new int[num_haves]; for (int i = 0; i < num_haves; i++) { piece_numbers[i] = ((Integer) pending_haves.get(i)).intValue(); } outgoing_message_q.addMessage(new AZHave(piece_numbers, az_have_version), true); } outgoing_message_q.doListenerNotifications(); pending_haves.clear(); } finally { pending_haves_mon.exit(); } }
/** * Create a new aggregator, which will send messages out the given queue. * * @param outgoing_message_q */ public OutgoingBTHaveMessageAggregator( OutgoingMessageQueue outgoing_message_q, byte _bt_have_version, byte _az_have_version) { this.outgoing_message_q = outgoing_message_q; bt_have_version = _bt_have_version; az_have_version = _az_have_version; outgoing_message_q.registerQueueListener(added_message_listener); }
/** Remove all outstanding piece data requests. */ public void removeAllPieceRequests() { if (destroyed) return; try { lock_mon.enter(); // removed this trace as Alon can't remember why the trace is here anyway and as far as I can // see there's nothing to stop a piece being delivered to transport and removed from // the message queue before we're notified of this and thus it is entirely possible that // our view of queued messages is lagging. // String before_trace = outgoing_message_queue.getQueueTrace(); /* int num_queued = queued_messages.size(); int num_removed = 0; for( Iterator i = queued_messages.keySet().iterator(); i.hasNext(); ) { BTPiece msg = (BTPiece)i.next(); if( outgoing_message_queue.removeMessage( msg, true ) ) { i.remove(); num_removed++; } } if( num_removed < num_queued -2 ) { Debug.out( "num_removed[" +num_removed+ "] < num_queued[" +num_queued+ "]:\nBEFORE:\n" +before_trace+ "\nAFTER:\n" +outgoing_message_queue.getQueueTrace() ); } */ for (Iterator i = queued_messages.keySet().iterator(); i.hasNext(); ) { BTPiece msg = (BTPiece) i.next(); outgoing_message_queue.removeMessage(msg, true); } queued_messages.clear(); // this replaces stuff above requests.clear(); loading_messages.clear(); } finally { lock_mon.exit(); } outgoing_message_queue.doListenerNotifications(); }
public void readCompleted(DiskManagerReadRequest request, DirectByteBuffer data) { try { lock_mon.enter(); if (!loading_messages.contains(request) || destroyed) { // was canceled data.returnToPool(); return; } loading_messages.remove(request); BTPiece msg = new BTPiece(request.getPieceNumber(), request.getOffset(), data, piece_version); queued_messages.put(msg, request); outgoing_message_queue.addMessage(msg, true); } finally { lock_mon.exit(); } outgoing_message_queue.doListenerNotifications(); }
/** * Create a new handler for outbound piece messages, reading piece data from the given disk * manager and transmitting the messages out the given message queue. * * @param disk_manager * @param outgoing_message_q */ public OutgoingBTPieceMessageHandler( PEPeer _peer, OutgoingMessageQueue _outgoing_message_q, OutgoingBTPieceMessageHandlerAdapter _adapter, byte _piece_version) { peer = _peer; outgoing_message_queue = _outgoing_message_q; adapter = _adapter; piece_version = _piece_version; outgoing_message_queue.registerQueueListener(sent_message_listener); }
public void destroy() { try { lock_mon.enter(); removeAllPieceRequests(); queued_messages.clear(); destroyed = true; outgoing_message_queue.cancelQueueListener(sent_message_listener); } finally { lock_mon.exit(); } }
/** * Queue a new have message for aggregated sending. * * @param piece_number of the have message * @param force if true, send this and any other pending haves right away */ public void queueHaveMessage(int piece_number, boolean force) { if (destroyed) return; try { pending_haves_mon.enter(); pending_haves.add(new Integer(piece_number)); if (force) { sendPendingHaves(); } else { int pending_bytes = pending_haves.size() * 9; if (pending_bytes >= outgoing_message_q.getMssSize()) { // System.out.println("enough pending haves for a full packet!"); // there's enough pending bytes to fill a packet payload sendPendingHaves(); } } } finally { pending_haves_mon.exit(); } }