globalmanagerimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   GlobalManagerImpl.java

package org.gudy.azureus2.core3.global.impl;

import com.aelitis.azureus.core.AzureusCore;
import com.aelitis.azureus.core.helpers.TorrentFolderWatcher;
import com.aelitis.azureus.core.peermanager.control.PeerControlScheduler;
import com.aelitis.azureus.core.peermanager.control.PeerControlSchedulerFactory;
import com.aelitis.azureus.core.util.CopyOnWriteList;
import java.io.*;
import java.net.URL;
import java.util.*;
import org.gudy.azureus2.core3.category.CategoryManager;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.download.*;
import org.gudy.azureus2.core3.download.impl.DownloadManagerAdapter;
import org.gudy.azureus2.core3.global.*;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.peer.PEPeerManager;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.torrent.TOTorrentException;
import org.gudy.azureus2.core3.tracker.client.*;
import org.gudy.azureus2.core3.tracker.util.TRTrackerUtils;
import org.gudy.azureus2.core3.tracker.util.TRTrackerUtilsListener;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.dht.mainline.MainlineDHTProvider;

// Referenced classes of package org.gudy.azureus2.core3.global.impl:
//			GlobalManagerHostSupport, GlobalManagerStatsImpl, GlobalManagerStatsWriter

public class GlobalManagerImpl extends DownloadManagerAdapter
	implements GlobalManager, AEDiagnosticsEvidenceGenerator
{
	public class Checker extends AEThread
	{

		int loopFactor;
		private static final int waitTime = 10000;
		private int saveResumeLoopCount;
		private int initSaveResumeLoopCount;
		private int natCheckLoopCount;
		private int seedPieceCheckCount;
		private AESemaphore run_sem;
		final GlobalManagerImpl this$0;

		private void determineSaveResumeDataInterval()
		{
			int saveResumeInterval = COConfigurationManager.getIntParameter("Save Resume Interval", 5);
			if (saveResumeInterval >= 1 && saveResumeInterval <= 90)
				saveResumeLoopCount = (saveResumeInterval * 60000) / 10000;
		}

		public void runSupport()
		{
			do
			{
				try
				{
					loopFactor++;
					determineSaveResumeDataInterval();
					if (loopFactor % saveResumeLoopCount == 0 || needsSaving && loadingComplete && loopFactor > initSaveResumeLoopCount)
						saveDownloads(true);
					if (loopFactor % natCheckLoopCount == 0)
					{
						computeNATStatus();
						checkSeedingOnlyState();
						checkForceStart(false);
					}
					if (loopFactor % seedPieceCheckCount == 0)
						seedPieceRecheck();
					Iterator it = managers_cow.iterator();
					do
					{
						if (!it.hasNext())
							break;
						DownloadManager manager = (DownloadManager)it.next();
						if (loopFactor % saveResumeLoopCount == 0)
							manager.saveResumeData();
					} while (true);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}
				try
				{
					run_sem.reserve(10000L);
					if (run_sem.isReleasedForever())
						break;
				}
				catch (Exception e)
				{
					Debug.printStackTrace(e);
				}
			} while (true);
		}

		public void stopIt()
		{
			run_sem.releaseForever();
		}

		public Checker()
		{
			this$0 = GlobalManagerImpl.this;
			super("Global Status Checker");
			saveResumeLoopCount = 30;
			initSaveResumeLoopCount = 6;
			natCheckLoopCount = 3;
			seedPieceCheckCount = 3;
			run_sem = new AESemaphore("GM:Checker:run");
			loopFactor = 0;
			setPriority(1);
		}
	}


	private static final LogIDs LOGID;
	private static final int LDT_MANAGER_ADDED = 1;
	private static final int LDT_MANAGER_REMOVED = 2;
	private static final int LDT_DESTROY_INITIATED = 3;
	private static final int LDT_DESTROYED = 4;
	private static final int LDT_SEEDING_ONLY = 5;
	private ListenerManager listeners;
	private static final int LDT_MANAGER_WBR = 1;
	private ListenerManager removal_listeners;
	private List managers_cow;
	private AEMonitor managers_mon;
	private Map manager_map;
	private GlobalMangerProgressListener progress_listener;
	private Checker checker;
	private GlobalManagerStatsImpl stats;
	private long last_swarm_stats_calc_time;
	private long last_swarm_stats;
	private boolean cripple_downloads_config;
	private TRTrackerScraper trackerScraper;
	private GlobalManagerStatsWriter stats_writer;
	private GlobalManagerHostSupport host_support;
	private Map saved_download_manager_state;
	private int next_seed_piece_recheck_index;
	private TorrentFolderWatcher torrent_folder_watcher;
	private ArrayList paused_list;
	private final AEMonitor paused_list_mon = new AEMonitor("GlobalManager:PL");
	private volatile boolean isStopping;
	private volatile boolean destroyed;
	private volatile boolean needsSaving;
	private boolean seeding_only_mode;
	private boolean potentially_seeding_only_mode;
	private FrequencyLimitedDispatcher check_seeding_only_state_dispatcher;
	private boolean force_start_non_seed_exists;
	private int nat_status;
	private boolean nat_status_probably_ok;
	private CopyOnWriteList dm_adapters;
	DelayedEvent loadTorrentsDelay;
	boolean loadingComplete;
	AESemaphore loadingSem;
	AEMonitor addingDM_monitor;
	List addingDMs;
	private MainlineDHTProvider provider;

	public GlobalManagerImpl(AzureusCore core, GlobalMangerProgressListener listener, long existingTorrentLoadDelay)
	{
		listeners = ListenerManager.createAsyncManager("GM:ListenDispatcher", new ListenerManagerDispatcher() {

			final GlobalManagerImpl this$0;

			public void dispatch(Object _listener, int type, Object value)
			{
				GlobalManagerListener target = (GlobalManagerListener)_listener;
				if (type == 1)
					target.downloadManagerAdded((DownloadManager)value);
				else
				if (type == 2)
					target.downloadManagerRemoved((DownloadManager)value);
				else
				if (type == 3)
					target.destroyInitiated();
				else
				if (type == 4)
					target.destroyed();
				else
				if (type == 5)
				{
					boolean temp[] = (boolean[])(boolean[])value;
					target.seedingStatusChanged(temp[0], temp[1]);
				}
			}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
		});
		removal_listeners = ListenerManager.createManager("GM:DLWBRMListenDispatcher", new ListenerManagerDispatcherWithException() {

			final GlobalManagerImpl this$0;

			public void dispatchWithException(Object _listener, int type, Object value)
				throws GlobalManagerDownloadRemovalVetoException
			{
				GlobalManagerDownloadWillBeRemovedListener target = (GlobalManagerDownloadWillBeRemovedListener)_listener;
				DownloadManager dm = (DownloadManager)((Object[])(Object[])value)[0];
				boolean remove_torrent = ((Boolean)((Object[])(Object[])value)[1]).booleanValue();
				boolean remove_data = ((Boolean)((Object[])(Object[])value)[2]).booleanValue();
				target.downloadWillBeRemoved(dm, remove_torrent, remove_data);
			}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
		});
		managers_cow = new ArrayList();
		managers_mon = new AEMonitor("GM:Managers");
		manager_map = new HashMap();
		last_swarm_stats_calc_time = 0L;
		last_swarm_stats = 0L;
		saved_download_manager_state = new HashMap();
		paused_list = new ArrayList();
		needsSaving = false;
		seeding_only_mode = false;
		potentially_seeding_only_mode = false;
		check_seeding_only_state_dispatcher = new FrequencyLimitedDispatcher(new AERunnable() {

			final GlobalManagerImpl this$0;

			public void runSupport()
			{
				checkSeedingOnlyStateSupport();
			}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
		}, 5000);
		nat_status = 0;
		dm_adapters = new CopyOnWriteList();
		loadTorrentsDelay = null;
		loadingComplete = false;
		loadingSem = new AESemaphore("Loading Torrents");
		addingDM_monitor = new AEMonitor("addingDM");
		addingDMs = new ArrayList();
		provider = null;
		progress_listener = listener;
		cripple_downloads_config = "1".equals(System.getProperty("azureus.disabledownloads"));
		AEDiagnostics.addEvidenceGenerator(this);
		stats = new GlobalManagerStatsImpl(this);
		try
		{
			stats_writer = new GlobalManagerStatsWriter(core);
		}
		catch (Throwable e)
		{
			Logger.log(new LogEvent(LOGID, "Stats unavailable", e));
		}
		if (existingTorrentLoadDelay > 0L)
			loadTorrentsDelay = new DelayedEvent("GM:tld", existingTorrentLoadDelay, new AERunnable() {

				final GlobalManagerImpl this$0;

				public void runSupport()
				{
					loadExistingTorrentsNow(false);
				}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
			});
		else
			loadDownloads();
		if (progress_listener != null)
			progress_listener.reportCurrentTask(MessageText.getString("splash.initializeGM"));
		trackerScraper = TRTrackerScraperFactory.getSingleton();
		trackerScraper.setClientResolver(new TRTrackerScraperClientResolver() {

			final GlobalManagerImpl this$0;

			public int getStatus(HashWrapper torrent_hash)
			{
				DownloadManager dm = getDownloadManager(torrent_hash);
				if (dm == null)
					return 1;
				int dm_state = dm.getState();
				if (dm_state == 75)
					return 3;
				return dm_state != 50 && dm_state != 60 ? 4 : 2;
			}

			public boolean isNetworkEnabled(HashWrapper hash, URL url)
			{
				DownloadManager dm = getDownloadManager(hash);
				if (dm == null)
					return false;
				String nw = AENetworkClassifier.categoriseAddress(url.getHost());
				String networks[] = dm.getDownloadState().getNetworks();
				for (int i = 0; i < networks.length; i++)
					if (networks[i] == nw)
						return true;

				return false;
			}

			public Object[] getExtensions(HashWrapper hash)
			{
				DownloadManager dm = getDownloadManager(hash);
				Character state;
				String ext;
				if (dm == null)
				{
					ext = "";
					state = TRTrackerScraperClientResolver.FL_NONE;
				} else
				{
					ext = dm.getDownloadState().getTrackerClientExtensions();
					if (ext == null)
						ext = "";
					boolean comp = dm.isDownloadComplete(false);
					int dm_state = dm.getState();
					if (dm_state == 100 || dm_state == 70 || dm_state == 65 && dm.getSubState() != 75)
						state = comp ? TRTrackerScraperClientResolver.FL_COMPLETE_STOPPED : TRTrackerScraperClientResolver.FL_INCOMPLETE_STOPPED;
					else
					if (dm_state == 50 || dm_state == 60)
						state = comp ? TRTrackerScraperClientResolver.FL_COMPLETE_RUNNING : TRTrackerScraperClientResolver.FL_INCOMPLETE_RUNNING;
					else
						state = comp ? TRTrackerScraperClientResolver.FL_COMPLETE_QUEUED : TRTrackerScraperClientResolver.FL_INCOMPLETE_QUEUED;
				}
				return (new Object[] {
					ext, state
				});
			}

			public boolean redirectTrackerUrl(HashWrapper hash, URL old_url, URL new_url)
			{
				DownloadManager dm = getDownloadManager(hash);
				if (dm == null || dm.getTorrent() == null)
					return false;
				else
					return TorrentUtils.replaceAnnounceURL(dm.getTorrent(), old_url, new_url);
			}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
		});
		trackerScraper.addListener(new TRTrackerScraperListener() {

			final GlobalManagerImpl this$0;

			public void scrapeReceived(TRTrackerScraperResponse response)
			{
				HashWrapper hash = response.getHash();
				DownloadManager manager = (DownloadManager)manager_map.get(hash);
				if (manager != null)
					manager.setTrackerScrapeResponse(response);
			}

			
			{
				this$0 = GlobalManagerImpl.this;
				super();
			}
		});
		try
		{
			host_support = new GlobalManagerHostSupport(this);
		}
		catch (Throwable e)
		{
			Logger.log(new LogEvent(LOGID, "Hosting unavailable", e));
		}
		checker = new Checker();
		checker.start();
		torrent_folder_watcher = new TorrentFolderWatcher(this);
		TRTrackerUtils.addListener(new TRTrackerUtilsListener() {

			final GlobalManagerImpl this$0;

			public void announceDetailsChanged()
			{
				Logger.log(new LogEvent(GlobalManagerImpl.LOGID, "Announce details have changed, updating trackers"));
				List managers = managers_cow;
				for (int i = 0; i < managers.size(); i++)
				{
					DownloadManager manager = (DownloadManager)managers.get(i);
					manager.requestTrackerAnnounce(true);
				}

			}

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

	public void loadExistingTorrentsNow(boolean async)
	{
		if (loadTorrentsDelay == null)
			return;
		loadTorrentsDelay = null;
		if (async)
		{
			AEThread thread = new AEThread("load torrents", true) {

				final GlobalManagerImpl this$0;

				public void runSupport()
				{
					loadDownloads();
				}

			
			{
				this$0 = GlobalManagerImpl.this;
				super(x0, x1);
			}
			};
			thread.setPriority(3);
			thread.start();
		} else
		{