pepeercontrolimpl.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:   PEPeerControlImpl.java

package org.gudy.azureus2.core3.peer.impl.control;

import com.aelitis.azureus.core.networkmanager.LimitedRateGroup;
import com.aelitis.azureus.core.networkmanager.impl.tcp.TCPConnectionManager;
import com.aelitis.azureus.core.networkmanager.impl.tcp.TCPNetworkManager;
import com.aelitis.azureus.core.networkmanager.impl.udp.UDPConnectionManager;
import com.aelitis.azureus.core.networkmanager.impl.udp.UDPNetworkManager;
import com.aelitis.azureus.core.peermanager.PeerManagerRegistration;
import com.aelitis.azureus.core.peermanager.control.*;
import com.aelitis.azureus.core.peermanager.nat.*;
import com.aelitis.azureus.core.peermanager.peerdb.*;
import com.aelitis.azureus.core.peermanager.piecepicker.PiecePicker;
import com.aelitis.azureus.core.peermanager.piecepicker.PiecePickerFactory;
import com.aelitis.azureus.core.peermanager.unchoker.*;
import com.aelitis.azureus.core.peermanager.uploadslots.UploadHelper;
import com.aelitis.azureus.core.peermanager.uploadslots.UploadSlotManager;
import com.aelitis.azureus.core.util.FeatureAvailability;
import com.aelitis.azureus.core.util.bloom.BloomFilter;
import com.aelitis.azureus.core.util.bloom.BloomFilterFactory;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.disk.*;
import org.gudy.azureus2.core3.ipfilter.*;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.peer.*;
import org.gudy.azureus2.core3.peer.impl.*;
import org.gudy.azureus2.core3.peer.util.*;
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.util.*;
import org.gudy.azureus2.plugins.peers.Peer;
import org.gudy.azureus2.plugins.peers.PeerDescriptor;

// Referenced classes of package org.gudy.azureus2.core3.peer.impl.control:
//			SuperSeedPeer, SuperSeedPiece

public class PEPeerControlImpl extends LogRelation
	implements PEPeerControl, ParameterListener, DiskManagerWriteRequestListener, PeerControlInstance, PeerNATInitiator, DiskManagerCheckRequestListener, IPFilterListener
{

	private static final LogIDs LOGID;
	private static final int WARNINGS_LIMIT = 2;
	private static final int CHECK_REASON_DOWNLOADED = 1;
	private static final int CHECK_REASON_COMPLETE = 2;
	private static final int CHECK_REASON_SCAN = 3;
	private static final int CHECK_REASON_SEEDING_CHECK = 4;
	private static final int CHECK_REASON_BAD_PIECE_CHECK = 5;
	private static final int SEED_CHECK_WAIT_MARKER = 65526;
	private static boolean disconnect_seeds_when_seeding;
	private static boolean enable_seeding_piece_rechecks;
	private static int stalled_piece_timeout;
	private static boolean fast_unchoke_new_peers;
	private static float ban_peer_discard_ratio;
	private static int ban_peer_discard_min_kb;
	private static boolean udp_fallback_for_failed_connection;
	private static boolean udp_fallback_for_dropped_connection;
	private static boolean udp_probe_enabled;
	private static boolean hide_a_piece;
	private static boolean prefer_udp_default;
	private static IpFilter ip_filter = IpFilterManagerFactory.getSingleton().getIPFilter();
	private volatile boolean is_running;
	private volatile boolean is_destroyed;
	private volatile ArrayList peer_transports_cow;
	private final AEMonitor peer_transports_mon = new AEMonitor("PEPeerControl:PT");
	protected final PEPeerManagerAdapter adapter;
	private final DiskManager disk_mgr;
	private final DiskManagerPiece dm_pieces[];
	private final PiecePicker piecePicker = PiecePickerFactory.create(this);
	private long lastNeededUndonePieceChange;
	private boolean seeding_mode;
	private boolean restart_initiated;
	private final int _nbPieces;
	private PEPieceImpl pePieces[];
	private int nbPiecesActive;
	private int nbPeersSnubbed;
	private PeerIdentityDataID _hash;
	private final byte _myPeerId[];
	private PEPeerManagerStats _stats;
	private int _seeds;
	private int _peers;
	private int _remotesNoUdpNoLan;
	private long last_remote_time;
	private long _timeStarted;
	private long _timeStartedSeeding;
	private long _timeFinished;
	private Average _averageReceptionSpeed;
	private long mainloop_loop_count;
	private static final int MAINLOOP_ONE_SECOND_INTERVAL;
	private static final int MAINLOOP_FIVE_SECOND_INTERVAL;
	private static final int MAINLOOP_TEN_SECOND_INTERVAL;
	private static final int MAINLOOP_THIRTY_SECOND_INTERVAL;
	private static final int MAINLOOP_SIXTY_SECOND_INTERVAL;
	private static final int MAINLOOP_TEN_MINUTE_INTERVAL;
	private volatile ArrayList peer_manager_listeners_cow;
	private final List piece_check_result_list = new ArrayList();
	private final AEMonitor piece_check_result_list_mon = new AEMonitor("PEPeerControl:PCRL");
	private boolean superSeedMode;
	private int superSeedModeCurrentPiece;
	private int superSeedModeNumberOfAnnounces;
	private SuperSeedPiece superSeedPieces[];
	private final int hidden_piece;
	private final AEMonitor this_mon = new AEMonitor("PEPeerControl");
	private long ip_filter_last_update_time;
	private Map user_data;
	private Unchoker unchoker;
	private List external_rate_limiters_cow;
	private List sweepList;
	private int nextPEXSweepIndex;
	private final UploadHelper upload_helper = new UploadHelper() {

		final PEPeerControlImpl this$0;

		public int getPriority()
		{
			return 4;
		}

		public ArrayList getAllPeers()
		{
			return peer_transports_cow;
		}

		public boolean isSeeding()
		{
			return seeding_mode;
		}

			
			{
				this$0 = PEPeerControlImpl.this;
				super();
			}
	};
	private PeerDatabase peer_database;
	private int bad_piece_reported;
	private int next_rescan_piece;
	private long rescan_piece_time;
	private long last_eta;
	private long last_eta_calculation;
	private static final int MAX_UDP_CONNECTIONS = 16;
	private static final int PENDING_NAT_TRAVERSAL_MAX = 32;
	private static final int MAX_UDP_TRAVERSAL_COUNT = 3;
	private static final String PEER_NAT_TRAVERSE_DONE_KEY = (new StringBuilder()).append(org/gudy/azureus2/core3/peer/impl/control/PEPeerControlImpl.getName()).append("::nat_trav_done").toString();
	private Map pending_nat_traversals;
	private int udp_traversal_count;
	private static final int UDP_RECONNECT_MAX = 16;
	private Map udp_reconnects;
	private static final int UDP_RECONNECT_MIN_MILLIS = 10000;
	private long last_udp_reconnect;
	private boolean prefer_udp;
	private static final int PREFER_UDP_BLOOM_SIZE = 10000;
	private volatile BloomFilter prefer_udp_bloom;
	private final LimitedRateGroup upload_limited_rate_group = new LimitedRateGroup() {

		final PEPeerControlImpl this$0;

		public String getName()
		{
			return (new StringBuilder()).append("per_dl_up: ").append(getDisplayName()).toString();
		}

		public int getRateLimitBytesPerSecond()
		{
			return adapter.getUploadRateLimitBytesPerSecond();
		}

			
			{
				this$0 = PEPeerControlImpl.this;
				super();
			}
	};
	private final LimitedRateGroup download_limited_rate_group = new LimitedRateGroup() {

		final PEPeerControlImpl this$0;

		public String getName()
		{
			return (new StringBuilder()).append("per_dl_down: ").append(getDisplayName()).toString();
		}

		public int getRateLimitBytesPerSecond()
		{
			return adapter.getDownloadRateLimitBytesPerSecond();
		}

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

	public PEPeerControlImpl(byte _peer_id[], PEPeerManagerAdapter _adapter, DiskManager diskManager)
	{
		is_running = false;
		is_destroyed = false;
		peer_transports_cow = new ArrayList();
		_timeStartedSeeding = -1L;
		peer_manager_listeners_cow = new ArrayList();
		sweepList = Collections.emptyList();
		nextPEXSweepIndex = 0;
		peer_database = PeerDatabaseFactory.createPeerDatabase();
		bad_piece_reported = -1;
		next_rescan_piece = -1;
		rescan_piece_time = -1L;
		pending_nat_traversals = new LinkedHashMap(32, 0.75F, true) {

			final PEPeerControlImpl this$0;

			protected boolean removeEldestEntry(java.util.Map.Entry eldest)
			{
				return size() > 32;
			}

			
			{
				this$0 = PEPeerControlImpl.this;
				super(x0, x1, x2);
			}
		};
		udp_reconnects = new LinkedHashMap(16, 0.75F, true) {

			final PEPeerControlImpl this$0;

			protected boolean removeEldestEntry(java.util.Map.Entry eldest)
			{
				return size() > 16;
			}

			
			{
				this$0 = PEPeerControlImpl.this;
				super(x0, x1, x2);
			}
		};
		_myPeerId = _peer_id;
		adapter = _adapter;
		disk_mgr = diskManager;
		_nbPieces = disk_mgr.getNbPieces();
		dm_pieces = disk_mgr.getPieces();
		pePieces = new PEPieceImpl[_nbPieces];
		hidden_piece = hide_a_piece ? (int)(Math.abs(adapter.getRandomSeed()) % (long)_nbPieces) : -1;
		if (hidden_piece >= 0)
			System.out.println((new StringBuilder()).append("Hidden piece for ").append(getDisplayName()).append(" = ").append(hidden_piece).toString());
		COConfigurationManager.addParameterListener("Ip Filter Enabled", this);
		ip_filter.addListener(this);
	}

	public void start()
	{
		try
		{
			_hash = PeerIdentityManager.createDataID(disk_mgr.getTorrent().getHash());
		}
		catch (TOTorrentException e)
		{
			Debug.printStackTrace(e);
			_hash = PeerIdentityManager.createDataID(new byte[20]);
		}
		for (int i = 0; i < _nbPieces; i++)
		{
			DiskManagerPiece dmPiece = dm_pieces[i];
			if (!dmPiece.isDone() && dmPiece.getNbWritten() > 0)
				addPiece(new PEPieceImpl(this, dmPiece, 0), i, true);
		}

		peer_transports_cow = new ArrayList();
		mainloop_loop_count = 0L;
		_averageReceptionSpeed = Average.getInstance(1000, 30);
		_stats = new PEPeerManagerStatsImpl(this);
		superSeedMode = COConfigurationManager.getBooleanParameter("Use Super Seeding") && getRemaining() == 0L;
		superSeedModeCurrentPiece = 0;
		if (superSeedMode)
			initialiseSuperSeedMode();
		checkFinished(true);
		UploadSlotManager.getSingleton().registerHelper(upload_helper);
		lastNeededUndonePieceChange = 0x8000000000000000L;
		_timeStarted = SystemTime.getCurrentTime();
		is_running = true;
		adapter.getPeerManagerRegistration().activate(this);
		PeerNATTraverser.getSingleton().register(this);
		PeerControlSchedulerFactory.getSingleton().register(this);
	}

	public void stopAll()
	{
		is_running = false;
		UploadSlotManager.getSingleton().deregisterHelper(upload_helper);
		PeerControlSchedulerFactory.getSingleton().unregister(this);
		PeerNATTraverser.getSingleton().unregister(this);
		adapter.getPeerManagerRegistration().deactivate();
		closeAndRemoveAllPeers("download stopped", false);
		for (int i = 0; i < _nbPieces; i++)
			if (pePieces[i] != null)
				removePiece(pePieces[i], i);

		COConfigurationManager.removeParameterListener("Ip Filter Enabled", this);
		ip_filter.removeListener(this);
		piecePicker.destroy();
		ArrayList peer_manager_listeners = peer_manager_listeners_cow;
		for (int i = 0; i < peer_manager_listeners.size(); i++)
			((PEPeerManagerListener)peer_manager_listeners.get(i)).destroyed();

		sweepList = Collections.emptyList();
		pending_nat_traversals.clear();
		udp_reconnects.clear();
		is_destroyed = true;
	}

	public boolean isDestroyed()
	{
		return is_destroyed;
	}

	public DiskManager getDiskManager()
	{
		return disk_mgr;
	}

	public PiecePicker getPiecePicker()
	{
		return piecePicker;
	}

	public PEPeerManagerAdapter getAdapter()
	{
		return adapter;
	}

	public String getDisplayName()
	{
		return adapter.getDisplayName();
	}

	public void schedule()
	{
		try
		{
			updateTrackerAnnounceInterval();
			doConnectionChecks();
			processPieceChecks();
			if (!seeding_mode)
				checkCompletedPieces();
			checkBadPieces();
			updateStats();
			checkInterested();
			piecePicker.updateAvailability();
			checkCompletionState();
			checkSeeds();
			if (!seeding_mode)
			{
				checkRequests();
				piecePicker.allocateRequests();
				checkRescan();
				checkSpeedAndReserved();
				check99PercentBug();
			}
			updatePeersInSuperSeedMode();
			doUnchokes();
		}
		catch (Throwable e)
		{
			Debug.printStackTrace(e);
		}
		mainloop_loop_count++;
	}

	private void analyseTrackerResponse(TRTrackerAnnouncerResponse tracker_response)
	{
		TRTrackerAnnouncerResponsePeer peers[] = tracker_response.getPeers();
		if (peers != null)
			addPeersFromTracker(tracker_response.getPeers());
		Map extensions = tracker_response.getExtensions();
		if (extensions != null)
			addExtendedPeersFromTracker(extensions);
	}

	public void processTrackerResponse(TRTrackerAnnouncerResponse response)
	{
		if (is_running)
			analyseTrackerResponse(response);
	}

	private void addExtendedPeersFromTracker(Map extensions)
	{
		Map protocols = (Map)extensions.get("protocols");
		if (protocols != null)
		{
			System.out.println("PEPeerControl: tracker response contained protocol extensions");
			for (Iterator protocol_it = protocols.keySet().iterator(); protocol_it.hasNext();)
			{
				String protocol_name = (String)protocol_it.next();
				Map protocol = (Map)protocols.get(protocol_name);
				List transports = PEPeerTransportFactory.createExtendedTransports(this, protocol_name, protocol);
				int i = 0;
				while (i < transports.size()) 
				{
					PEPeer transport = (PEPeer)transports.get(i);
					addPeer(transport);
					i++;
				}
			}

		}
	}

	public List getPeers()
	{
		return peer_transports_cow;
	}

	public List getPeers(String address)
	{
		List result = new ArrayList();
		Iterator it = peer_transports_cow.iterator();
		do