globalmanagerimpl.java

基于JXTA开发平台的下载软件开发源代码

							// Debug.dumpThreads("Azureus: slow stop - thread dump");
							
							// Debug.killAWTThreads(); doesn't work
						}
					}
				}						
			};
					
		t.setDaemon(true);
				
		t.start();
		*/

  		listeners.dispatch( LDT_DESTROYED, null, true );
  }
  	
  public void 
  informDestroyInitiated()  
  {
  	listeners.dispatch( LDT_DESTROY_INITIATED, null, true );		
  }
  	
 	public void
	addListener(
		GlobalManagerListener	listener )
	{
		if ( isStopping ){
				
			listener.destroyed();
				
		}else{			
							
			listeners.addListener(listener);

			// Don't use Dispatch.. async is bad (esp for plugin initialization)
			try{
				managers_mon.enter();
			
				for (int i=0;i<managers_cow.size();i++){
					
				  listener.downloadManagerAdded((DownloadManager)managers_cow.get(i));
				}	
			}finally{
				
				managers_mon.exit();
			}
		}
	}
		
	public void
 	removeListener(
		GlobalManagerListener	listener )
	{			
		listeners.removeListener(listener);
	}
	
	public void
	addDownloadWillBeRemovedListener(
		GlobalManagerDownloadWillBeRemovedListener	l )
	{
		removal_listeners.addListener( l );
	}
	
	public void
	removeDownloadWillBeRemovedListener(
		GlobalManagerDownloadWillBeRemovedListener	l )
	{
		removal_listeners.removeListener( l );
	}
  
  // DownloadManagerListener
  public void 
  stateChanged(
	DownloadManager 	manager, 
	int 				new_state ) 
  {
    needsSaving = true;  //make sure we update 'downloads.config' on state changes
    
    	//run seeding-only-mode check
    
   PEPeerManager	pm_manager = manager.getPeerManager();
    
    if ( 	new_state == DownloadManager.STATE_DOWNLOADING && 
    		pm_manager != null &&
    		pm_manager.hasDownloadablePiece()){
    	
    	//the new state is downloading, so can skip the full check
    	
    	setSeedingOnlyState( false );
    	
    }else{
    	
    	checkSeedingOnlyState();
    }
  }
  
  protected void
  checkSeedingOnlyState()
  {
    boolean seeding = false;
    	
    List managers = managers_cow;
    
    for( int i=0; i < managers.size(); i++ ) {
    	  
        DownloadManager dm = (DownloadManager)managers.get( i );

        PEPeerManager pm = dm.getPeerManager();
        
        if ( dm.getDiskManager() == null || pm == null ){
        	
        		// download not running, not interesting
        	
        	continue;
        }
        
        int	state = dm.getState();
        
        if ( state == DownloadManager.STATE_DOWNLOADING ){
        	
        	if (!pm.hasDownloadablePiece()){
        		
        			// complete DND file
        		
        		seeding = true;
        		
        	}else{
        		
        		seeding = false;
        		
        		break;
        	}
        }else if ( state == DownloadManager.STATE_SEEDING ){
        	
        	seeding = true;
        }
    }
    
    setSeedingOnlyState( seeding );
  }
  
  
  protected void
  setSeedingOnlyState(
		boolean	seeding )
  { 
    if( seeding != seeding_only_mode ) {
      seeding_only_mode = seeding;
      listeners.dispatch( LDT_SEEDING_ONLY, new Boolean( seeding_only_mode ) );
    }
  }
		
  public boolean
  isSeedingOnly()
  {
	  return( seeding_only_mode );
  }
  
  
  	public void downloadComplete(DownloadManager manager) { }

  	public void completionChanged(DownloadManager manager, boolean bCompleted) { }
  
  	public void positionChanged(DownloadManager download, int oldPosition, int newPosition) {
  	}
  
	public long 
	getTotalSwarmsPeerRate(
		boolean 	downloading, 
		boolean 	seeding )
	{
		long	now = SystemTime.getCurrentTime();
		
		if ( 	now < last_swarm_stats_calc_time ||
				now - last_swarm_stats_calc_time >= 1000 ){
			
			long	total = 0;
					
			List	managers = managers_cow;
			
			for (int i=0;i<managers.size();i++){
				
				DownloadManager	manager = (DownloadManager)managers.get(i);

				boolean	is_seeding = manager.getState() == DownloadManager.STATE_SEEDING;
				
				if (	( downloading && !is_seeding ) ||
						( seeding && is_seeding )){
					
					total += manager.getStats().getTotalAveragePerPeer();
				}
			}
			
			last_swarm_stats	= total;
			
			last_swarm_stats_calc_time	= now;
		}
		
		return( last_swarm_stats );
	}
	
	protected void
	computeNATStatus()
	{
		int	num_ok			= 0;
		int num_probably_ok	= 0;
		int	num_bad			= 0;
		
        for (Iterator it=managers_cow.iterator();it.hasNext();) {
          	
        	DownloadManager manager = (DownloadManager)it.next();

        	int	status = manager.getNATStatus();
        	
        	if ( status == ConnectionManager.NAT_OK ){
        		
        		num_ok++;
        		
        	}else if ( status == ConnectionManager.NAT_PROBABLY_OK ){
        		
        		num_probably_ok++;
        		
        	}else if ( status == ConnectionManager.NAT_BAD ){
            		
            	num_bad++;
        	}
        }
        
        if ( num_ok > 0 ){
        	
        	nat_status = ConnectionManager.NAT_OK;
        	
        }else if ( num_probably_ok > 0 || nat_status_probably_ok ){
        	
        	nat_status 				= ConnectionManager.NAT_PROBABLY_OK;
        	
        	nat_status_probably_ok	= true;
        	
        }else if ( num_bad > 0 ){
        	
        	nat_status = ConnectionManager.NAT_BAD;
        	
        }else{
        	
        	nat_status = ConnectionManager.NAT_UNKNOWN;
        }
	}
	
	public int
	getNATStatus()
	{	
		return( nat_status );
	}
	
	protected void
	checkNetwork()
	{
		try{
			Enumeration 	nis = NetworkInterface.getNetworkInterfaces();
		
			Set	network_interfaces = new HashSet();
			
			boolean	changed	= false;
			
			while( nis.hasMoreElements()){
				
				Object	 ni = nis.nextElement();
				
					// NetworkInterface's "equals" method is based on ni name + addresses
				
				if ( old_network_interfaces != null && !old_network_interfaces.contains( ni )){
					
					changed	= true;
				}
				
				network_interfaces.add( ni );
			}
						
			if ( changed ){
				
				long now	= SystemTime.getCurrentTime();
				
					// don't pick up "change" on first time through
				
				if ( last_network_change > 0 ){
					
					if ( now - last_network_change > 30*60*1000 ){
					
						Logger.log(new LogEvent(LOGID,
								"Network interfaces have changed, updating trackers"));
						
						List	managers = managers_cow;
						
						for (int i=0;i<managers.size();i++){
							
							DownloadManager	manager = (DownloadManager)managers.get(i);
							
							TRTrackerAnnouncer	anouncer = manager.getTrackerClient();
							
							if ( anouncer != null ){
								
								anouncer.update( true );
							}
						}
					}else{
						
						Logger.log(new LogEvent(LOGID, "Network interfaces have changed, "
								+ "not updating trackers as too soon after previous change"));
	
					}
				}
				
				last_network_change	= now;
			}
			
			old_network_interfaces	= network_interfaces;
			
		}catch( Throwable e ){
		}
	}
	 
	public void
	generate(
		IndentWriter		writer )
	{
		writer.println( "Global Manager" );

		try{
			writer.indent();
		
	    	managers_mon.enter();
	    	
			writer.println( "  managers: " + managers_cow.size());
		
			for (int i=0;i<managers_cow.size();i++){
				
				DownloadManager	manager = (DownloadManager)managers_cow.get(i);
				
				TOTorrent	torrent = manager.getTorrent();
				
				String	hash = "<unknown>";
				
				try{
					hash = ByteFormatter.encodeString( torrent.getHash());
					
				}catch( Throwable e ){
				}
				
				writer.println( "    " + manager.getDisplayName() + "/" + hash + " (" + manager + ")");
			}

	    }finally{
			
			managers_mon.exit();
			
			writer.exdent();
	    }
	}
	
	public static void
	main(
		String[]	args )
	{
		if ( args.length == 0 ){
			args = new String[]{ 
					"C:\\temp\\downloads.config", 
					"C:\\temp\\downloads-9-3-05.config", 
					"C:\\temp\\merged.config" };
			
		}else if ( args.length != 3 ){
			
			System.out.println( "Usage: newer_config_file older_config_file save_config_file" );
			
			return;
		}
		
		try{
			Map	map1 = FileUtil.readResilientFile( new File(args[0]));
			Map	map2 = FileUtil.readResilientFile( new File(args[1]));
			
			List	downloads1 = (List)map1.get( "downloads" );
			List	downloads2 = (List)map2.get( "downloads" );
			
			Set	torrents = new HashSet();
			
			Iterator	it1 = downloads1.iterator();
			
			while( it1.hasNext()){
				
				Map	m = (Map)it1.next();
				
				byte[]	hash = (byte[])m.get( "torrent_hash" );
				
				System.out.println( "1:" + ByteFormatter.nicePrint(hash));
				
				torrents.add( new HashWrapper( hash ));
			}
			
			List	to_add = new ArrayList();
			
			Iterator	it2 = downloads2.iterator();
			
			while( it2.hasNext()){
				
				Map	m = (Map)it2.next();
				
				byte[]	hash = (byte[])m.get( "torrent_hash" );
				
				HashWrapper	wrapper = new HashWrapper( hash );
				
				if ( torrents.contains( wrapper )){
					
					System.out.println( "-:" + ByteFormatter.nicePrint(hash));
					
				}else{
					
					System.out.println( "2:" + ByteFormatter.nicePrint(hash));
					
					to_add.add( m );
				}
			}
			
			downloads1.addAll( to_add );
			
			System.out.println( to_add.size() + " copied from " + args[1] + " to " + args[2]);
			
			FileUtil.writeResilientFile( new File( args[2]), map1 );
			
		}catch( Throwable e ){
			
			e.printStackTrace();
		}
	}
}