pepeercontrolimpl.java

java 文件下载器。可自定义

				rescan_piece_time = now;
				Debug.printStackTrace(e);
			}
			break;
		} while (true);
	}

	public void badPieceReported(PEPeerTransport originator, int piece_number)
	{
		Debug.outNoStack((new StringBuilder()).append(getDisplayName()).append(": bad piece #").append(piece_number).append(" reported by ").append(originator.getIp()).toString());
		if (piece_number < 0 || piece_number >= _nbPieces)
		{
			return;
		} else
		{
			bad_piece_reported = piece_number;
			return;
		}
	}

	private void checkFinished(boolean start_of_day)
	{
		boolean all_pieces_done = disk_mgr.getRemainingExcludingDND() == 0L;
		if (all_pieces_done)
		{
			seeding_mode = true;
			prefer_udp_bloom = null;
			piecePicker.clearEndGameChunks();
			if (!start_of_day)
				adapter.setStateFinishing();
			_timeFinished = SystemTime.getCurrentTime();
			ArrayList peer_transports = peer_transports_cow;
			for (int i = 0; i < peer_transports.size(); i++)
			{
				PEPeerTransport pc = (PEPeerTransport)peer_transports.get(i);
				pc.setSnubbed(false);
			}

			setNbPeersSnubbed(0);
			boolean checkPieces = COConfigurationManager.getBooleanParameter("Check Pieces on Completion");
			if (checkPieces && !start_of_day)
			{
				DiskManagerCheckRequest req = disk_mgr.createCheckRequest(-1, new Integer(2));
				disk_mgr.enqueueCompleteRecheckRequest(req, this);
			}
			_timeStartedSeeding = SystemTime.getCurrentTime();
			try
			{
				disk_mgr.saveResumeData(false);
			}
			catch (Throwable e)
			{
				Debug.out("Failed to save resume data", e);
			}
			adapter.setStateSeeding(start_of_day);
			disk_mgr.downloadEnded();
		} else
		{
			seeding_mode = false;
		}
	}

	protected void checkCompletionState()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		boolean dm_done = disk_mgr.getRemainingExcludingDND() == 0L;
		if (seeding_mode)
		{
			if (!dm_done)
			{
				seeding_mode = false;
				_timeStartedSeeding = -1L;
				_timeFinished = 0L;
				Logger.log(new LogEvent(disk_mgr.getTorrent(), LOGID, "Turning off seeding mode for PEPeerManager"));
			}
		} else
		if (dm_done)
		{
			checkFinished(false);
			if (seeding_mode)
				Logger.log(new LogEvent(disk_mgr.getTorrent(), LOGID, "Turning on seeding mode for PEPeerManager"));
		}
	}

	private void checkRequests()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		long now = SystemTime.getCurrentTime();
		ArrayList peer_transports = peer_transports_cow;
		for (int i = peer_transports.size() - 1; i >= 0; i--)
		{
			PEPeerTransport pc = (PEPeerTransport)peer_transports.get(i);
			if (pc.getPeerState() != 30)
				continue;
			List expired = pc.getExpiredRequests();
			if (expired == null || expired.size() <= 0)
				continue;
			boolean isSeed = pc.isSeed();
			long timeSinceGoodData = pc.getTimeSinceGoodDataReceived();
			if (timeSinceGoodData < 0L || timeSinceGoodData > 60000L)
				pc.setSnubbed(true);
			DiskManagerReadRequest request = (DiskManagerReadRequest)expired.get(0);
			long timeSinceData = pc.getTimeSinceLastDataMessageReceived();
			boolean noData = timeSinceData < 0L || timeSinceData > (long)(1000 * (isSeed ? 120 : 60));
			long timeSinceOldestRequest = now - request.getTimeCreated(now);
			for (int j = timeSinceOldestRequest <= 0x1d4c0L || !noData ? 1 : 0; j < expired.size(); j++)
			{
				request = (DiskManagerReadRequest)expired.get(j);
				pc.sendCancel(request);
				int pieceNumber = request.getPieceNumber();
				PEPiece pe_piece = pePieces[pieceNumber];
				if (pe_piece != null)
					pe_piece.clearRequested(request.getOffset() / 16384);
				if (!piecePicker.isInEndGameMode())
					checkEmptyPiece(pieceNumber);
			}

		}

	}

	private void updateTrackerAnnounceInterval()
	{
		if (mainloop_loop_count % (long)MAINLOOP_FIVE_SECOND_INTERVAL != 0L)
			return;
		int WANT_LIMIT = 100;
		int num_wanted = getMaxNewConnectionsAllowed();
		boolean has_remote = adapter.isNATHealthy();
		if (has_remote)
			num_wanted = (int)((double)num_wanted / 1.5D);
		if (num_wanted < 0 || num_wanted > 100)
			num_wanted = 100;
		int current_connection_count = PeerIdentityManager.getIdentityCount(_hash);
		TRTrackerScraperResponse tsr = adapter.getTrackerScrapeResponse();
		if (tsr != null && tsr.isValid())
		{
			int num_seeds = tsr.getSeeds();
			int num_peers = tsr.getPeers();
			int swarm_size;
			if (seeding_mode)
			{
				float ratio = (float)num_peers / (float)(num_seeds + num_peers);
				swarm_size = (int)((float)num_peers * ratio);
			} else
			{
				swarm_size = num_peers + num_seeds;
			}
			if (swarm_size < num_wanted)
				num_wanted = swarm_size;
		}
		if (num_wanted < 1)
		{
			adapter.setTrackerRefreshDelayOverrides(100);
			return;
		}
		if (current_connection_count == 0)
			current_connection_count = 1;
		int current_percent = (current_connection_count * 100) / (current_connection_count + num_wanted);
		adapter.setTrackerRefreshDelayOverrides(current_percent);
	}

	public boolean hasDownloadablePiece()
	{
		return piecePicker.hasDownloadablePiece();
	}

	public int[] getAvailability()
	{
		return piecePicker.getAvailability();
	}

	public float getMinAvailability()
	{
		return piecePicker.getMinAvailability();
	}

	public float getAvgAvail()
	{
		return piecePicker.getAvgAvail();
	}

	public long getAvailWentBadTime()
	{
		return piecePicker.getAvailWentBadTime();
	}

	public void addPeerTransport(PEPeerTransport transport)
	{
		if (!ip_filter.isInRange(transport.getIp(), getDisplayName(), getTorrentHash()))
		{
			ArrayList peer_transports = peer_transports_cow;
			if (!peer_transports.contains(transport))
			{
				addToPeerTransports(transport);
			} else
			{
				Debug.out("addPeerTransport():: peer_transports.contains(transport): SHOULD NEVER HAPPEN !");
				transport.closeConnection("already connected");
			}
		} else
		{
			transport.closeConnection("IP address blocked by filters");
		}
	}

	private void doUnchokes()
	{
		if (!UploadSlotManager.AUTO_SLOT_ENABLE)
		{
			if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
				return;
			int max_to_unchoke = adapter.getMaxUploads();
			ArrayList peer_transports = peer_transports_cow;
			if (seeding_mode)
			{
				if (unchoker == null || !(unchoker instanceof SeedingUnchoker))
					unchoker = new SeedingUnchoker();
			} else
			if (unchoker == null || !(unchoker instanceof DownloadingUnchoker))
				unchoker = new DownloadingUnchoker();
			if (mainloop_loop_count % (long)MAINLOOP_TEN_SECOND_INTERVAL == 0L)
			{
				boolean refresh = mainloop_loop_count % (long)MAINLOOP_THIRTY_SECOND_INTERVAL == 0L;
				unchoker.calculateUnchokes(max_to_unchoke, peer_transports, refresh, adapter.hasPriorityConnection());
				ArrayList chokes = unchoker.getChokes();
				ArrayList unchokes = unchoker.getUnchokes();
				addFastUnchokes(unchokes);
				UnchokerUtil.performChokes(chokes, unchokes);
			} else
			if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL == 0L)
			{
				ArrayList unchokes = unchoker.getImmediateUnchokes(max_to_unchoke, peer_transports);
				addFastUnchokes(unchokes);
				UnchokerUtil.performChokes(null, unchokes);
			}
		}
	}

	private void addFastUnchokes(ArrayList peers_to_unchoke)
	{
		Iterator it = peer_transports_cow.iterator();
		do
		{
			if (!it.hasNext())
				break;
			PEPeerTransport peer = (PEPeerTransport)it.next();
			if (peer.getConnectionState() == 4 && UnchokerUtil.isUnchokable(peer, true) && !peers_to_unchoke.contains(peer))
				if (peer.isLANLocal())
					peers_to_unchoke.add(peer);
				else
				if (fast_unchoke_new_peers && peer.getData("fast_unchoke_done") == null)
				{
					peer.setData("fast_unchoke_done", "");
					peers_to_unchoke.add(peer);
				}
		} while (true);
	}

	private void sendHave(int pieceNumber)
	{
		ArrayList peer_transports = peer_transports_cow;
		for (int i = 0; i < peer_transports.size(); i++)
		{
			PEPeerTransport pc = (PEPeerTransport)peer_transports.get(i);
			pc.sendHave(pieceNumber);
		}

	}

	private void checkSeeds()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		if (!disconnect_seeds_when_seeding)
			return;
		ArrayList to_close = null;
		ArrayList peer_transports = peer_transports_cow;
		for (int i = 0; i < peer_transports.size(); i++)
		{
			PEPeerTransport pc = (PEPeerTransport)peer_transports.get(i);
			if (pc == null || pc.getPeerState() != 30 || (!isSeeding() || !pc.isSeed()) && !pc.isRelativeSeed())
				continue;
			if (to_close == null)
				to_close = new ArrayList();
			to_close.add(pc);
		}

		if (to_close != null)
		{
			for (int i = 0; i < to_close.size(); i++)
				closeAndRemovePeer((PEPeerTransport)to_close.get(i), "disconnect other seed when seeding", false);

		}
	}

	private void updateStats()
	{
		if (mainloop_loop_count % (long)MAINLOOP_ONE_SECOND_INTERVAL != 0L)
			return;
		ArrayList peer_transports = peer_transports_cow;
		int new_seeds = 0;
		int new_peers = 0;
		int newTcpRemotes = 0;
		Iterator it = peer_transports.iterator();
		do
		{
			if (!it.hasNext())
				break;
			PEPeerTransport pc = (PEPeerTransport)it.next();
			if (pc.getPeerState() == 30)
			{
				if (pc.isSeed())
					new_seeds++;
				else
					new_peers++;
				if (pc.isIncoming() && pc.isTCP() && !pc.isLANLocal())
					newTcpRemotes++;
			}
		} while (true);
		_seeds = new_seeds;
		_peers = new_peers;
		_remotesNoUdpNoLan = newTcpRemotes;
	}

	public void requestCanceled(DiskManagerReadRequest request)
	{
		int pieceNumber = request.getPieceNumber();
		PEPiece pe_piece = pePieces[pieceNumber];
		if (pe_piece != null)
			pe_piece.clearRequested(request.getOffset() / 16384);
	}

	public PEPeerControl getControl()
	{
		return this;
	}

	public byte[][] getSecrets(int crypto_level)
	{
		return adapter.getSecrets(crypto_level);
	}

	public byte[] getHash()
	{
		return _hash.getDataID();
	}

	public PeerIdentityDataID getPeerIdentityDataID()
	{
		return _hash;
	}

	public byte[] getPeerId()
	{
		return _myPeerId;
	}

	public long getRemaining()
	{
		return disk_mgr.getRemaining();
	}

	public void discarded(PEPeer peer, int length)
	{
		if (length > 0)
		{
			_stats.discarded(peer, length);
			if (ban_peer_discard_ratio > 0.0F && !piecePicker.isInEndGameMode() && !piecePicker.hasEndGameModeBeenAbandoned())
			{
				long received = peer.getStats().getTotalDataBytesReceived();
				long discarded = peer.getStats().getTotalBytesDiscarded();
				long non_discarded = received - discarded;
				if (non_discarded < 0L)
					non_discarded = 0L;
				if (discarded >= (long)(ban_peer_discard_min_kb * 1024) && (non_discarded == 0L || (float)discarded / (float)non_discarded >= ban_peer_discard_ratio))
					badPeerDetected(peer.getIp(), -1);
			}
		}
	}

	public void dataBytesReceived(PEPeer peer, int length)
	{
		if (length > 0)
		{
			_stats.dataBytesReceived(peer, length);
			_averageReceptionSpeed.addValue(length);
		}
	}

	public void protocolBytesReceived(PEPeer peer, int length)
	{
		if (length > 0)
			_stats.protocolBytesReceived(peer, length);
	}

	public void dataBytesSent(PEPeer peer, int length)
	{
		if (length > 0)
			_stats.dataBytesSent(peer, length);
	}

	public void protocolBytesSent(PEPeer peer, int length)
	{
		if (length > 0)
			_stats.protocolBytesSent(peer, length);
	}

	public void writeCompleted(DiskManagerWriteRequest request)
	{
		int pieceNumber = request.getPieceNumber();
		DiskManagerPiece dm_piece = dm_pieces[pieceNumber];
		if (!dm_piece.isDone())
		{
			PEPiece pePiece = pePieces[pieceNumber];
			if (pePiece != null)
				pePiece.setWritten((PEPeer)request.getUserData(), request.getOffset() / 16384);
			else
				dm_piece.setWritten(request.getOffset() / 16384);
		}
	}

	public void writeFailed(DiskManagerWriteRequest diskmanagerwriterequest, Throwable throwable)
	{
	}

	public DirectByteBuffer[] write(long data_offset, DirectByteBuffer data[])