1 /* 2 * File : PeerManagerImpl.java 3 * Created : 28-Dec-2003 4 * By : parg 5 * 6 * Azureus - a Java Bittorrent client 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details ( see the LICENSE file ). 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 package org.gudy.azureus2.pluginsimpl.local.peers; 24 25 /** 26 * @author parg 27 * 28 */ 29 30 import java.util.*; 31 32 import org.gudy.azureus2.core3.disk.DiskManagerFileInfo; 33 import org.gudy.azureus2.core3.disk.DiskManagerListener; 34 import org.gudy.azureus2.core3.disk.DiskManagerPiece; 35 import org.gudy.azureus2.core3.disk.DiskManagerReadRequest; 36 import org.gudy.azureus2.core3.peer.*; 37 import org.gudy.azureus2.core3.util.AEMonitor; 38 import org.gudy.azureus2.core3.util.Debug; 39 import org.gudy.azureus2.core3.util.TorrentUtils; 40 import org.gudy.azureus2.plugins.disk.DiskManager; 41 import org.gudy.azureus2.plugins.download.*; 42 import org.gudy.azureus2.plugins.peers.*; 43 import org.gudy.azureus2.plugins.torrent.Torrent; 44 import org.gudy.azureus2.plugins.utils.PooledByteBuffer; 45 import org.gudy.azureus2.pluginsimpl.local.PluginCoreUtils; 46 import org.gudy.azureus2.pluginsimpl.local.disk.DiskManagerImpl; 47 import org.gudy.azureus2.pluginsimpl.local.download.DownloadManagerImpl; 48 import org.gudy.azureus2.pluginsimpl.local.utils.PooledByteBufferImpl; 49 50 import com.aelitis.azureus.core.networkmanager.NetworkManager; 51 import com.aelitis.azureus.core.peermanager.peerdb.PeerItem; 52 53 public class 54 PeerManagerImpl 55 implements PeerManager 56 { 57 private static final String PEPEER_DATA_KEY = PeerManagerImpl.class.getName(); 58 59 protected PEPeerManager manager; 60 61 protected static AEMonitor pm_map_mon = new AEMonitor( "PeerManager:Map" ); 62 63 public static PeerManagerImpl getPeerManager( PEPeerManager _manager )64 getPeerManager( 65 PEPeerManager _manager ) 66 { 67 try{ 68 pm_map_mon.enter(); 69 70 PeerManagerImpl res = (PeerManagerImpl)_manager.getData( "PluginPeerManager" ); 71 72 if ( res == null ){ 73 74 res = new PeerManagerImpl( _manager ); 75 76 _manager.setData( "PluginPeerManager", res ); 77 } 78 79 return( res ); 80 }finally{ 81 82 pm_map_mon.exit(); 83 } 84 } 85 86 private Map foreign_map = new HashMap(); 87 88 private Map<PeerManagerListener,PEPeerManagerListener> listener_map1 = new HashMap<PeerManagerListener,PEPeerManagerListener>(); 89 private Map<PeerManagerListener2,CoreListener> listener_map2 = new HashMap<PeerManagerListener2,CoreListener>(); 90 91 protected AEMonitor this_mon = new AEMonitor( "PeerManager" ); 92 93 private final DiskManagerPiece[] dm_pieces; 94 private final PEPiece[] pe_pieces; 95 private pieceFacade[] piece_facades; 96 97 private boolean destroyed; 98 99 protected PeerManagerImpl( PEPeerManager _manager )100 PeerManagerImpl( 101 PEPeerManager _manager ) 102 { 103 manager = _manager; 104 105 dm_pieces = _manager.getDiskManager().getPieces(); 106 pe_pieces = _manager.getPieces(); 107 108 manager.addListener( 109 new PEPeerManagerListenerAdapter() 110 { 111 public void 112 peerRemoved( 113 PEPeerManager manager, 114 PEPeer peer ) 115 { 116 PeerImpl dele = getPeerForPEPeer( peer ); 117 118 if ( dele != null ){ 119 120 dele.closed(); 121 } 122 } 123 124 public void 125 destroyed() 126 { 127 synchronized( foreign_map ){ 128 129 destroyed = true; 130 131 Iterator it = foreign_map.values().iterator(); 132 133 while( it.hasNext()){ 134 135 try{ 136 ((PeerForeignDelegate)it.next()).stop(); 137 138 }catch( Throwable e ){ 139 140 Debug.printStackTrace( e ); 141 } 142 } 143 } 144 } 145 }); 146 } 147 148 public PEPeerManager getDelegate()149 getDelegate() 150 { 151 return( manager ); 152 } 153 154 public DiskManager getDiskManager()155 getDiskManager() 156 { 157 return( new DiskManagerImpl( manager.getDiskManager())); 158 } 159 160 public PeerManagerStats getStats()161 getStats() 162 { 163 return(new PeerManagerStatsImpl( manager)); 164 } 165 166 public boolean isSeeding()167 isSeeding() 168 { 169 // this is the wrong thing to check for seeding.. 170 return( manager.getDiskManager().getRemainingExcludingDND() == 0 ); //yuck 171 } 172 173 public boolean isSuperSeeding()174 isSuperSeeding() 175 { 176 return( manager.isSuperSeedMode()); 177 } 178 179 public Download getDownload()180 getDownload() 181 182 throws DownloadException 183 { 184 return( DownloadManagerImpl.getDownloadStatic( manager.getDiskManager().getTorrent())); 185 } 186 187 public Piece[] getPieces()188 getPieces() 189 { 190 if ( piece_facades == null ){ 191 192 pieceFacade[] pf = new pieceFacade[manager.getDiskManager().getNbPieces()]; 193 194 for (int i=0;i<pf.length;i++){ 195 196 pf[i] = new pieceFacade(i); 197 } 198 199 piece_facades = pf; 200 } 201 202 return( piece_facades ); 203 } 204 205 public PeerStats createPeerStats( Peer peer )206 createPeerStats( 207 Peer peer ) 208 { 209 PEPeer delegate = mapForeignPeer( peer ); 210 211 return( new PeerStatsImpl( this, peer, manager.createPeerStats( delegate ))); 212 } 213 214 215 public void requestComplete( PeerReadRequest request, PooledByteBuffer data, Peer sender)216 requestComplete( 217 PeerReadRequest request, 218 PooledByteBuffer data, 219 Peer sender) 220 { 221 manager.writeBlock( 222 request.getPieceNumber(), 223 request.getOffset(), 224 ((PooledByteBufferImpl)data).getBuffer(), 225 mapForeignPeer( sender ), 226 false); 227 228 PeerForeignDelegate delegate = lookupForeignPeer( sender ); 229 230 if ( delegate != null ){ 231 232 delegate.dataReceived(); 233 } 234 } 235 236 public void requestCancelled( PeerReadRequest request, Peer sender )237 requestCancelled( 238 PeerReadRequest request, 239 Peer sender ) 240 { 241 manager.requestCanceled((DiskManagerReadRequest)request ); 242 } 243 244 protected int getPartitionID()245 getPartitionID() 246 { 247 return( manager.getPartitionID()); 248 } 249 250 // these are foreign peers 251 252 public void addPeer( Peer peer )253 addPeer( 254 Peer peer ) 255 { 256 // no private check here, we come through here for webseeds for example 257 258 manager.addPeer(mapForeignPeer( peer )); 259 } 260 261 public void removePeer( Peer peer )262 removePeer( 263 Peer peer ) 264 { 265 manager.removePeer(mapForeignPeer( peer )); 266 } 267 268 protected void removePeer( Peer peer, String reason )269 removePeer( 270 Peer peer, 271 String reason ) 272 { 273 manager.removePeer(mapForeignPeer( peer ), reason ); 274 } 275 276 public void addPeer( String ip_address, int tcp_port )277 addPeer( 278 String ip_address, 279 int tcp_port ) 280 { 281 addPeer( 282 ip_address, 283 tcp_port, 284 0, 285 NetworkManager.getCryptoRequired( NetworkManager.CRYPTO_OVERRIDE_NONE )); 286 } 287 288 public void addPeer( String ip_address, int tcp_port, boolean use_crypto )289 addPeer( 290 String ip_address, 291 int tcp_port, 292 boolean use_crypto ) 293 { 294 addPeer( ip_address, tcp_port, 0, use_crypto ); 295 } 296 297 public void addPeer( String ip_address, int tcp_port, int udp_port, boolean use_crypto )298 addPeer( 299 String ip_address, 300 int tcp_port, 301 int udp_port, 302 boolean use_crypto ) 303 { 304 addPeer( ip_address, tcp_port, udp_port, use_crypto, null ); 305 } 306 307 public void addPeer( String ip_address, int tcp_port, int udp_port, boolean use_crypto, Map user_data )308 addPeer( 309 String ip_address, 310 int tcp_port, 311 int udp_port, 312 boolean use_crypto, 313 Map user_data ) 314 { 315 checkIfPrivate(); 316 317 if ( pluginPeerSourceEnabled()){ 318 319 manager.addPeer( ip_address, tcp_port, udp_port, use_crypto, user_data ); 320 } 321 } 322 323 public void peerDiscovered( String peer_source, String ip_address, int tcp_port, int udp_port, boolean use_crypto )324 peerDiscovered( 325 String peer_source, 326 String ip_address, 327 int tcp_port, 328 int udp_port, 329 boolean use_crypto ) 330 { 331 checkIfPrivate(); 332 333 if ( manager.isPeerSourceEnabled( peer_source )){ 334 335 manager.peerDiscovered( peer_source, ip_address, tcp_port, udp_port, use_crypto ); 336 } 337 } 338 339 protected boolean pluginPeerSourceEnabled()340 pluginPeerSourceEnabled() 341 { 342 if ( manager.isPeerSourceEnabled( PEPeerSource.PS_PLUGIN )){ 343 344 return( true ); 345 346 }else{ 347 348 Debug.out( "Plugin peer source disabled for " + manager.getDisplayName()); 349 350 return( false ); 351 } 352 } 353 354 protected void checkIfPrivate()355 checkIfPrivate() 356 { 357 Download dl; 358 359 try{ 360 dl = getDownload(); 361 362 }catch( Throwable e ){ 363 364 // if this didn't work then nothing much else will so just fall through 365 366 return; 367 } 368 369 Torrent t = dl.getTorrent(); 370 371 if ( t != null ){ 372 373 if ( TorrentUtils.isReallyPrivate( PluginCoreUtils.unwrap( t ))){ 374 375 throw( new RuntimeException( "Torrent is private, peer addition not permitted" )); 376 } 377 } 378 } 379 380 public Peer[] getPeers()381 getPeers() 382 { 383 List l = manager.getPeers(); 384 385 Peer[] res= new Peer[l.size()]; 386 387 // this is all a bit shagged as we should maintain the PEPeer -> Peer link rather 388 // than continually creating new PeerImpls... 389 390 for (int i=0;i<res.length;i++){ 391 392 res[i] = getPeerForPEPeer((PEPeer)l.get(i)); 393 } 394 395 return( res ); 396 } 397 398 public Peer[] getPeers( String address )399 getPeers( 400 String address ) 401 { 402 List l = manager.getPeers( address ); 403 404 Peer[] res= new Peer[l.size()]; 405 406 // this is all a bit shagged as we should maintain the PEPeer -> Peer link rather 407 // than continually creating new PeerImpls... 408 409 for (int i=0;i<res.length;i++){ 410 411 res[i] = getPeerForPEPeer((PEPeer)l.get(i)); 412 } 413 414 return( res ); 415 } 416 417 418 public PeerDescriptor[] getPendingPeers()419 getPendingPeers() 420 { 421 return( manager.getPendingPeers()); 422 } 423 424 public PeerDescriptor[] getPendingPeers( String address )425 getPendingPeers( 426 String address ) 427 { 428 return( manager.getPendingPeers( address )); 429 } 430 431 public long getTimeSinceConnectionEstablished( Peer peer )432 getTimeSinceConnectionEstablished( 433 Peer peer ) 434 { 435 if ( peer instanceof PeerImpl ){ 436 437 return(((PeerImpl)peer).getDelegate().getTimeSinceConnectionEstablished()); 438 }else{ 439 PeerForeignDelegate delegate = lookupForeignPeer( peer ); 440 441 if ( delegate != null ){ 442 443 return( delegate.getTimeSinceConnectionEstablished()); 444 445 }else{ 446 447 return( 0 ); 448 } 449 } 450 } 451 public PEPeer mapForeignPeer( Peer _foreign )452 mapForeignPeer( 453 Peer _foreign ) 454 { 455 if ( _foreign instanceof PeerImpl ){ 456 457 return(((PeerImpl)_foreign).getDelegate()); 458 } 459 460 synchronized( foreign_map ){ 461 462 PEPeer local = (PEPeer)foreign_map.get( _foreign ); 463 464 if ( local != null && local.isClosed()){ 465 466 foreign_map.remove( _foreign ); 467 468 local = null; 469 } 470 471 if( local == null ){ 472 473 if ( destroyed ){ 474 475 Debug.out( "Peer added to destroyed peer manager" ); 476 477 return( null ); 478 } 479 480 local = new PeerForeignDelegate( this, _foreign ); 481 482 _foreign.setUserData( PeerManagerImpl.class, local ); 483 484 foreign_map.put( _foreign, local ); 485 } 486 487 return( local ); 488 } 489 } 490 491 protected PeerForeignDelegate lookupForeignPeer( Peer _foreign )492 lookupForeignPeer( 493 Peer _foreign ) 494 { 495 return((PeerForeignDelegate)_foreign.getUserData( PeerManagerImpl.class )); 496 } 497 498 public List mapForeignPeers( Peer[] _foreigns )499 mapForeignPeers( 500 Peer[] _foreigns ) 501 { 502 List res = new ArrayList(); 503 504 for (int i=0;i<_foreigns.length;i++){ 505 506 PEPeer local = mapForeignPeer( _foreigns[i]); 507 508 // could already be there if torrent contains two identical seeds (for whatever reason) 509 510 if ( !res.contains( local )){ 511 512 res.add( local ); 513 } 514 } 515 516 return( res ); 517 } 518 519 public static PeerImpl getPeerForPEPeer( PEPeer pe_peer )520 getPeerForPEPeer( 521 PEPeer pe_peer ) 522 { 523 PeerImpl peer = (PeerImpl)pe_peer.getData( PEPEER_DATA_KEY ); 524 525 if ( peer == null ){ 526 527 peer = new PeerImpl( pe_peer ); 528 529 pe_peer.setData( PEPEER_DATA_KEY, peer ); 530 } 531 532 return( peer ); 533 } 534 535 public int getUploadRateLimitBytesPerSecond()536 getUploadRateLimitBytesPerSecond() 537 { 538 return( manager.getUploadRateLimitBytesPerSecond()); 539 } 540 541 public int getDownloadRateLimitBytesPerSecond()542 getDownloadRateLimitBytesPerSecond() 543 { 544 return( manager.getDownloadRateLimitBytesPerSecond()); 545 } 546 547 public void addListener( final PeerManagerListener l )548 addListener( 549 final PeerManagerListener l ) 550 { 551 try{ 552 this_mon.enter(); 553 554 final Map peer_map = new HashMap(); 555 556 PEPeerManagerListener core_listener = new PEPeerManagerListenerAdapter() { 557 public void peerAdded( PEPeerManager manager, PEPeer peer ) { 558 PeerImpl pi = getPeerForPEPeer( peer ); 559 peer_map.put( peer, pi ); 560 l.peerAdded( PeerManagerImpl.this, pi ); 561 } 562 563 public void peerRemoved( PEPeerManager manager, PEPeer peer ) { 564 PeerImpl pi = (PeerImpl)peer_map.remove( peer ); 565 566 if ( pi == null ){ 567 // somewhat inconsistently we get told here about the removal of 568 // peers that never connected (and weren't added) 569 // Debug.out( "PeerManager: peer not found"); 570 } 571 else{ 572 l.peerRemoved( PeerManagerImpl.this, pi ); 573 } 574 } 575 }; 576 577 listener_map1.put( l, core_listener ); 578 579 manager.addListener( core_listener ); 580 }finally{ 581 582 this_mon.exit(); 583 } 584 } 585 586 public void removeListener( PeerManagerListener l )587 removeListener( 588 PeerManagerListener l ) 589 { 590 try{ 591 this_mon.enter(); 592 593 PEPeerManagerListener core_listener = (PEPeerManagerListener)listener_map1.remove( l ); 594 595 if ( core_listener != null ){ 596 597 manager.removeListener( core_listener ); 598 } 599 600 }finally{ 601 this_mon.exit(); 602 } 603 } 604 605 public void addListener( final PeerManagerListener2 l )606 addListener( 607 final PeerManagerListener2 l ) 608 { 609 try{ 610 this_mon.enter(); 611 612 CoreListener core_listener = new CoreListener( l ); 613 614 listener_map2.put( l, core_listener ); 615 616 manager.addListener( core_listener ); 617 618 manager.getDiskManager().addListener( core_listener ); 619 }finally{ 620 621 this_mon.exit(); 622 } 623 } 624 625 public void removeListener( PeerManagerListener2 l )626 removeListener( 627 PeerManagerListener2 l ) 628 { 629 try{ 630 this_mon.enter(); 631 632 CoreListener core_listener = listener_map2.remove( l ); 633 634 if ( core_listener != null ){ 635 636 manager.removeListener( core_listener ); 637 638 manager.getDiskManager().removeListener( core_listener ); 639 } 640 641 }finally{ 642 643 this_mon.exit(); 644 } 645 } 646 647 protected class 648 pieceFacade 649 implements Piece 650 { 651 private final int index; 652 653 protected pieceFacade( int _index )654 pieceFacade( 655 int _index ) 656 { 657 index = _index; 658 } 659 660 public int getIndex()661 getIndex() 662 { 663 return( index ); 664 } 665 666 public int getLength()667 getLength() 668 { 669 return( dm_pieces[index].getLength()); 670 } 671 672 public boolean isDone()673 isDone() 674 { 675 return( dm_pieces[index].isDone()); 676 } 677 678 public boolean isNeeded()679 isNeeded() 680 { 681 return( dm_pieces[index].isNeeded()); 682 } 683 684 public boolean isDownloading()685 isDownloading() 686 { 687 return( pe_pieces[index] != null ); 688 } 689 690 public boolean isFullyAllocatable()691 isFullyAllocatable() 692 { 693 if ( pe_pieces[index] != null ){ 694 695 return( false ); 696 } 697 698 return( dm_pieces[index].isInteresting()); 699 } 700 701 public int getAllocatableRequestCount()702 getAllocatableRequestCount() 703 { 704 PEPiece pe_piece = pe_pieces[index]; 705 706 if ( pe_piece != null ){ 707 708 return( pe_piece.getNbUnrequested()); 709 } 710 711 if ( dm_pieces[index].isInteresting() ){ 712 713 return( dm_pieces[index].getNbBlocks()); 714 } 715 716 return( 0 ); 717 } 718 719 public Peer getReservedFor()720 getReservedFor() 721 { 722 PEPiece piece = pe_pieces[index]; 723 724 if ( piece != null ){ 725 726 String ip = piece.getReservedBy(); 727 728 if ( ip != null ){ 729 730 List<PEPeer> peers = manager.getPeers( ip ); 731 732 if ( peers.size() > 0 ){ 733 734 return( getPeerForPEPeer( peers.get(0))); 735 } 736 } 737 } 738 739 return( null ); 740 } 741 742 public void setReservedFor( Peer peer )743 setReservedFor( 744 Peer peer ) 745 { 746 PEPiece piece = pe_pieces[index]; 747 748 PEPeer mapped_peer = mapForeignPeer( peer ); 749 750 if ( piece != null && mapped_peer != null ){ 751 752 piece.setReservedBy( peer.getIp()); 753 754 mapped_peer.addReservedPieceNumber( index ); 755 } 756 } 757 } 758 759 private class 760 CoreListener 761 implements PEPeerManagerListener, DiskManagerListener 762 { 763 private PeerManagerListener2 listener; 764 private Map<PEPeer, Peer> peer_map = new HashMap<PEPeer, Peer>(); 765 766 private CoreListener( PeerManagerListener2 _listener )767 CoreListener( 768 PeerManagerListener2 _listener ) 769 { 770 listener = _listener; 771 } 772 773 public void peerAdded( PEPeerManager manager, PEPeer peer )774 peerAdded( 775 PEPeerManager manager, PEPeer peer ) 776 { 777 PeerImpl pi = getPeerForPEPeer( peer ); 778 779 peer_map.put( peer, pi ); 780 781 fireEvent( 782 PeerManagerEvent.ET_PEER_ADDED, 783 pi, 784 null, 785 null ); 786 } 787 788 public void peerRemoved( PEPeerManager manager, PEPeer peer )789 peerRemoved( 790 PEPeerManager manager, 791 PEPeer peer ) 792 { 793 PeerImpl pi = (PeerImpl)peer_map.remove( peer ); 794 795 if ( pi == null ){ 796 797 }else{ 798 799 fireEvent( 800 PeerManagerEvent.ET_PEER_REMOVED, 801 pi, 802 null, 803 null ); 804 } 805 } 806 807 public void peerDiscovered( PEPeerManager manager, PeerItem peer_item, PEPeer finder )808 peerDiscovered( 809 PEPeerManager manager, 810 PeerItem peer_item, 811 PEPeer finder ) 812 { 813 PeerImpl pi; 814 815 if ( finder != null ){ 816 817 pi = getPeerForPEPeer( finder ); 818 819 peer_map.put( finder, pi ); 820 821 }else{ 822 823 pi = null; 824 } 825 826 fireEvent( 827 PeerManagerEvent.ET_PEER_DISCOVERED, 828 pi, 829 peer_item, 830 null ); 831 } 832 833 public void pieceAdded( PEPeerManager manager, PEPiece piece, PEPeer for_peer )834 pieceAdded( 835 PEPeerManager manager, 836 PEPiece piece, 837 PEPeer for_peer ) 838 { 839 PeerImpl pi = for_peer==null?null:getPeerForPEPeer( for_peer ); 840 841 fireEvent( 842 PeerManagerEvent.ET_PIECE_ACTIVATED, 843 pi, 844 null, 845 new pieceFacade( piece.getPieceNumber())); 846 } 847 848 public void pieceRemoved( PEPeerManager manager, PEPiece piece )849 pieceRemoved( 850 PEPeerManager manager, 851 PEPiece piece ) 852 { 853 fireEvent( 854 PeerManagerEvent.ET_PIECE_DEACTIVATED, 855 null, 856 null, 857 new pieceFacade( piece.getPieceNumber())); 858 } 859 860 public void peerSentBadData( PEPeerManager manager, PEPeer peer, int pieceNumber)861 peerSentBadData( 862 PEPeerManager manager, 863 PEPeer peer, 864 int pieceNumber) 865 { 866 PeerImpl pi = getPeerForPEPeer( peer ); 867 868 peer_map.put( peer, pi ); 869 870 fireEvent( 871 PeerManagerEvent.ET_PEER_SENT_BAD_DATA, 872 pi, 873 null, 874 new Integer( pieceNumber )); 875 876 } 877 878 public void pieceCorrupted( PEPeerManager manager, int piece_number)879 pieceCorrupted( 880 PEPeerManager manager, 881 int piece_number) 882 { 883 } 884 885 // disk manager methods 886 887 public void stateChanged( int oldState, int newState )888 stateChanged( 889 int oldState, 890 int newState ) 891 { 892 } 893 894 public void filePriorityChanged( DiskManagerFileInfo file )895 filePriorityChanged( 896 DiskManagerFileInfo file ) 897 { 898 } 899 900 public void pieceDoneChanged( DiskManagerPiece piece )901 pieceDoneChanged( 902 DiskManagerPiece piece ) 903 { 904 fireEvent( 905 PeerManagerEvent.ET_PIECE_COMPLETION_CHANGED, 906 null, 907 null, 908 new pieceFacade( piece.getPieceNumber())); 909 } 910 911 public void fileAccessModeChanged( DiskManagerFileInfo file, int old_mode, int new_mode )912 fileAccessModeChanged( 913 DiskManagerFileInfo file, 914 int old_mode, 915 int new_mode ) 916 { 917 } 918 919 protected void fireEvent( final int type, final Peer peer, final PeerItem peer_item, final Object data )920 fireEvent( 921 final int type, 922 final Peer peer, 923 final PeerItem peer_item, 924 final Object data ) 925 { 926 listener.eventOccurred( 927 new PeerManagerEvent() 928 { 929 public PeerManager 930 getPeerManager() 931 { 932 return( PeerManagerImpl.this ); 933 } 934 935 public int 936 getType() 937 { 938 return( type ); 939 } 940 941 public Peer 942 getPeer() 943 { 944 return( peer ); 945 } 946 947 public PeerDescriptor 948 getPeerDescriptor() 949 { 950 return( peer_item ); 951 } 952 953 public Object 954 getData() 955 { 956 return( data ); 957 } 958 }); 959 } 960 961 962 public void destroyed()963 destroyed() 964 { 965 } 966 } 967 } 968