globalmanagerimpl.java

java 文件下载器。可自定义

	public void informDestroyInitiated()
	{
		listeners.dispatch(3, null, true);
	}

	public void addListener(GlobalManagerListener listener)
	{
		addListener(listener, true);
	}

	public void addListener(GlobalManagerListener listener, boolean trigger)
	{
		if (isStopping)
		{
			listener.destroyed();
			break MISSING_BLOCK_LABEL_100;
		}
		listeners.addListener(listener);
		if (!trigger)
			return;
		managers_mon.enter();
		List managers = managers_cow;
		for (int i = 0; i < managers.size(); i++)
			listener.downloadManagerAdded((DownloadManager)managers.get(i));

		managers_mon.exit();
		break MISSING_BLOCK_LABEL_100;
		Exception exception;
		exception;
		managers_mon.exit();
		throw exception;
	}

	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);
	}

	public void stateChanged(DownloadManager manager, int new_state)
	{
		needsSaving = true;
		PEPeerManager pm_manager = manager.getPeerManager();
		if (new_state == 50 && pm_manager != null && pm_manager.hasDownloadablePiece())
			setSeedingOnlyState(false, false);
		else
			checkSeedingOnlyState();
		checkForceStart(manager.isForceStart() && new_state == 50);
	}

	protected void checkForceStart(boolean known_to_exist)
	{
		boolean exists;
		if (known_to_exist)
		{
			exists = true;
		} else
		{
			exists = false;
			if (force_start_non_seed_exists)
			{
				List managers = managers_cow;
				int i = 0;
				do
				{
					if (i >= managers.size())
						break;
					DownloadManager dm = (DownloadManager)managers.get(i);
					if (dm.isForceStart() && dm.getState() == 50)
					{
						exists = true;
						break;
					}
					i++;
				} while (true);
			}
		}
		if (exists != force_start_non_seed_exists)
		{
			force_start_non_seed_exists = exists;
			Logger.log(new LogEvent(LOGID, (new StringBuilder()).append("Force start download ").append(force_start_non_seed_exists ? "exists" : "doesn't exist").append(", modifying download weighting").toString()));
			PeerControlSchedulerFactory.getSingleton().overrideWeightedPriorities(force_start_non_seed_exists);
		}
	}

	protected void checkSeedingOnlyState()
	{
		check_seeding_only_state_dispatcher.dispatch();
	}

	protected void checkSeedingOnlyStateSupport()
	{
		boolean seeding = false;
		boolean seeding_set = false;
		boolean potentially_seeding = false;
		List managers = managers_cow;
		for (int i = 0; i < managers.size(); i++)
		{
			DownloadManager dm = (DownloadManager)managers.get(i);
			PEPeerManager pm = dm.getPeerManager();
			int state = dm.getState();
			if (dm.getDiskManager() == null || pm == null)
			{
				if (state != 75)
					continue;
				if (dm.isDownloadComplete(false))
				{
					potentially_seeding = true;
				} else
				{
					seeding = false;
					seeding_set = true;
				}
				continue;
			}
			if (state == 50)
			{
				if (!pm.hasDownloadablePiece())
				{
					if (!seeding_set)
						seeding = true;
					continue;
				}
				seeding = false;
				potentially_seeding = false;
				break;
			}
			if (state == 60 && !seeding_set)
				seeding = true;
		}

		if (seeding)
			potentially_seeding = true;
		setSeedingOnlyState(seeding, potentially_seeding);
	}

	protected void setSeedingOnlyState(boolean seeding, boolean potentially_seeding)
	{
		synchronized (this)
		{
			if (seeding != seeding_only_mode || potentially_seeding != potentially_seeding_only_mode)
			{
				seeding_only_mode = seeding;
				potentially_seeding_only_mode = potentially_seeding;
				listeners.dispatch(5, new boolean[] {
					seeding_only_mode, potentially_seeding_only_mode
				});
			}
		}
	}

	public boolean isSeedingOnly()
	{
		return seeding_only_mode;
	}

	public boolean isPotentiallySeedingOnly()
	{
		return potentially_seeding_only_mode;
	}

	public long getTotalSwarmsPeerRate(boolean downloading, boolean seeding)
	{
		long now = SystemTime.getCurrentTime();
		if (now < last_swarm_stats_calc_time || now - last_swarm_stats_calc_time >= 1000L)
		{
			long total = 0L;
			List managers = managers_cow;
			for (int i = 0; i < managers.size(); i++)
			{
				DownloadManager manager = (DownloadManager)managers.get(i);
				boolean is_seeding = manager.getState() == 60;
				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;
		Iterator it = managers_cow.iterator();
		do
		{
			if (!it.hasNext())
				break;
			DownloadManager manager = (DownloadManager)it.next();
			int status = manager.getNATStatus();
			if (status == 1)
				num_ok++;
			else
			if (status == 2)
				num_probably_ok++;
			else
			if (status == 3)
				num_bad++;
		} while (true);
		if (num_ok > 0)
			nat_status = 1;
		else
		if (num_probably_ok > 0 || nat_status_probably_ok)
		{
			nat_status = 2;
			nat_status_probably_ok = true;
		} else
		if (num_bad > 0)
			nat_status = 3;
		else
			nat_status = 0;
	}

	public int getNATStatus()
	{
		return nat_status;
	}

	protected void seedPieceRecheck()
	{
		List managers = managers_cow;
		if (next_seed_piece_recheck_index >= managers.size())
			next_seed_piece_recheck_index = 0;
		for (int i = next_seed_piece_recheck_index; i < managers.size(); i++)
		{
			DownloadManager manager = (DownloadManager)managers.get(i);
			if (seedPieceRecheck(manager))
			{
				next_seed_piece_recheck_index = i + 1;
				if (next_seed_piece_recheck_index >= managers.size())
					next_seed_piece_recheck_index = 0;
				return;
			}
		}

		for (int i = 0; i < next_seed_piece_recheck_index; i++)
		{
			DownloadManager manager = (DownloadManager)managers.get(i);
			if (seedPieceRecheck(manager))
			{
				next_seed_piece_recheck_index = i + 1;
				if (next_seed_piece_recheck_index >= managers.size())
					next_seed_piece_recheck_index = 0;
				return;
			}
		}

	}

	protected boolean seedPieceRecheck(DownloadManager manager)
	{
		if (manager.getState() != 60)
			return false;
		else
			return manager.seedPieceRecheck();
	}

	protected DownloadManagerInitialisationAdapter getDMAdapter(DownloadManagerInitialisationAdapter adapter)
	{
		List adapters = dm_adapters.getList();
		if (adapters.size() == 0)
			return adapter;
		if (adapter != null)
		{
			adapters = new ArrayList(adapters);
			adapters.add(adapter);
		}
		if (adapters.size() == 1)
		{
			return (DownloadManagerInitialisationAdapter)adapters.get(0);
		} else
		{
			final List f_adapters = adapters;
			return new DownloadManagerInitialisationAdapter() {

				final List val$f_adapters;
				final GlobalManagerImpl this$0;

				public void initialised(DownloadManager manager)
				{
					for (int i = 0; i < f_adapters.size(); i++)
						try
						{
							((DownloadManagerInitialisationAdapter)f_adapters.get(i)).initialised(manager);
						}
						catch (Throwable e)
						{
							Debug.printStackTrace(e);
						}

				}

			
			{
				this$0 = GlobalManagerImpl.this;
				f_adapters = list;
				super();
			}
			};
		}
	}

	public void addDownloadManagerInitialisationAdapter(DownloadManagerInitialisationAdapter adapter)
	{
		dm_adapters.add(adapter);
	}

	public void removeDownloadManagerInitialisationAdapter(DownloadManagerInitialisationAdapter adapter)
	{
		dm_adapters.remove(adapter);
	}

	public void generate(IndentWriter writer)
	{
		writer.println("Global Manager");
		int i;
		writer.indent();
		managers_mon.enter();
		writer.println((new StringBuilder()).append("  managers: ").append(managers_cow.size()).toString());
		i = 0;
_L2:
		DownloadManager manager;
		if (i >= managers_cow.size())
			break; /* Loop/switch isn't completed */
		manager = (DownloadManager)managers_cow.get(i);
		writer.indent();
		manager.generateEvidence(writer);
		Exception exception;
		writer.exdent();
		i++;
		continue; /* Loop/switch isn't completed */
		exception;
		writer.exdent();
		throw exception;
		if (true) goto _L2; else goto _L1
_L1:
		managers_mon.exit();
		writer.exdent();
		break MISSING_BLOCK_LABEL_142;
		Exception exception1;
		exception1;
		managers_mon.exit();
		writer.exdent();
		throw exception1;
	}

	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();
			byte hash[];
			for (Iterator it1 = downloads1.iterator(); it1.hasNext(); torrents.add(new HashWrapper(hash)))
			{
				Map m = (Map)it1.next();
				hash = (byte[])(byte[])m.get("torrent_hash");
				System.out.println((new StringBuilder()).append("1:").append(ByteFormatter.nicePrint(hash)).toString());
			}

			List to_add = new ArrayList();
			for (Iterator it2 = downloads2.iterator(); it2.hasNext();)
			{
				Map m = (Map)it2.next();
				byte hash[] = (byte[])(byte[])m.get("torrent_hash");
				HashWrapper wrapper = new HashWrapper(hash);
				if (torrents.contains(wrapper))
				{
					System.out.println((new StringBuilder()).append("-:").append(ByteFormatter.nicePrint(hash)).toString());
				} else
				{
					System.out.println((new StringBuilder()).append("2:").append(ByteFormatter.nicePrint(hash)).toString());
					to_add.add(m);
				}
			}

			downloads1.addAll(to_add);
			System.out.println((new StringBuilder()).append(to_add.size()).append(" copied from ").append(args[1]).append(" to ").append(args[2]).toString());
			FileUtil.writeResilientFile(new File(args[2]), map1);
		}
		catch (Throwable e)
		{
			e.printStackTrace();
		}
	}

	public void setMainlineDHTProvider(MainlineDHTProvider provider)
	{
		this.provider = provider;
	}

	public MainlineDHTProvider getMainlineDHTProvider()
	{
		return provider;
	}

	static 
	{
		LOGID = LogIDs.CORE;
	}





}