downloadsession.java

JMule是一个基于Java开发

					
						completeDownload();
						
						return ;
						
					}
					Packet sendPacket = PacketFactory.getUploadReuqestPacket(sharedFile.getFileHash());
					sender.sendPacket(sendPacket);
					download_status_list.setPeerStatus(sender, PeerDownloadStatus.UPLOAD_REQUEST);
					List<PeerDownloadStatus> status_list = download_status_list.getPeersByStatus(PeerDownloadStatus.HASHSET_REQUEST, PeerDownloadStatus.ACTIVE_UNUSED);
					for(PeerDownloadStatus peer_status : status_list) {
						peer_status.getPeer().sendPacket(PacketFactory.getUploadReuqestPacket(sharedFile.getFileHash()));
						peer_status.setPeerStatus(PeerDownloadStatus.UPLOAD_REQUEST);
					}
					
				}
			FragmentList list = fileRequestList.get(sender);
			if (list != null)
				if (this.fileRequestList.get(sender).size()!=0) {
					//Have to receive more packets
					return ;
				}
			
			fileChunkRequest(sender);
			
			
			
			return ;
			
		}
		
		
		if (packet instanceof JMPeerFileNotFoundSP ) {
			
			download_status_list.updatePeerHistory(sender,OP_FILEREQANSNOFILE);
			
			download_status_list.setPeerStatus(sender,PeerDownloadStatus.DISCONNECTED);
			
			sender.disconnect();
			
			return ;
			
		}
		
		if (packet instanceof JMPeerSlotTakenSP ) {
						
			download_status_list.updatePeerHistory(sender,OP_SLOTTAKEN);
			
			download_status_list.setPeerStatus(sender, PeerDownloadStatus.SLOTREQUEST);
			
			return;
			
		}
		
		if (packet instanceof JMPeerQueueRankingSP ) {
			
			JMPeerQueueRankingSP scannedPacket = (JMPeerQueueRankingSP) packet;
						
			download_status_list.updatePeerHistory(sender,OP_EMULE_QUEUERANKING,scannedPacket.getQueueRanking());
			
			download_status_list.setPeerStatus(sender, PeerDownloadStatus.IN_QUEUE);
			
			
			return ;
		}
		
	}
	

	private void queueSources() {
		
		Server server;
		
		server = ServerManagerFactory.getInstance().getConnectedServer();
		
		if (server!=null)
			
			server.requestSources(sharedFile.getFileHash(), sharedFile.length());
		
		/** Queue peers for sources **/
		
		//List<Peer> peerList = PeerManagerFactory.getInstance().getPeers(getFileHash());
		
		//for(Peer p : peerList) {
			
		//	if (p.getStatus() == Peer.TCP_SOCKET_CONNECTED) {
				
				//Packet packet = EMulePacketFactory.getSourcesRequestPacket(sharedFile.getFileHash());
				
				//p.sendPacket(packet);
		//	}
		//}
		
	}
	
	

	private void completeDownload() {
		
		stopDownload();
		
		try { 
		  SharingManagerFactory.getInstance().makeCompletedFile(sharedFile.getFileHash());
		}catch(Throwable t) {
			
		}
	
		DownloadManagerFactory.getInstance().removeDownload(getFileHash());
	}
	
	private void fileChunkRequest(Peer peer) {
				
		long blockSize = ConfigurationManagerFactory.getInstance().getDownloadBandwidth();
				
		if (blockSize > BLOCKSIZE)
			
				blockSize = BLOCKSIZE;
				
		FileChunkRequest fragments[] = downloadStrategy.fileChunk3Request(peer, blockSize, this.sharedFile.length(),
				sharedFile.getGapList(), partStatus, fileRequestList);
		
		int unused = 0;
		
		for(int i = 0;i<fragments.length;i++) {
			//System.out.println(fragments[i]);
			if (((fragments[i].getChunkBegin()==fragments[i].getChunkEnd())&&(fragments[i].getChunkBegin()==0)))
				
				unused++;
		}
		if (unused==3){
			
			download_status_list.setPeerStatus(peer, PeerDownloadStatus.ACTIVE_UNUSED);
			
			download_status_list.getDownloadStatus(peer).setLastFilePartRequest(null);
			
			return;
			
			}
		
		download_status_list.setPeerStatus(peer, PeerDownloadStatus.ACTIVE);
		
		Packet packet2 = PacketFactory.getPeerRequestFileParts(sharedFile.getFileHash(),
				new long[]{fragments[0].getChunkBegin(),fragments[1].getChunkBegin(),fragments[2].getChunkBegin(),
				   fragments[0].getChunkEnd(),  fragments[1].getChunkEnd(),  fragments[2].getChunkEnd()} );
		
		download_status_list.getDownloadStatus(peer).setLastFilePartRequest(packet2);
		
		peer.sendPacket(packet2);
	}
	
	public float getSpeed() {
		
		float downloadSpeed = 0;
		
		for(Peer peer : peer_list)
			
			downloadSpeed += peer.getDownloadSpeed();
		
		return downloadSpeed;
	}

	public FileHash getFileHash() {
		
		return this.sharedFile.getFileHash();
		
	}

	public String getSharingName() {
		
		return sharedFile.getSharingName();
		
	}
	
	public GapList getGapList() {
		
		return this.sharedFile.getGapList();
		
	}
	
	public long getETA() {
		float speed = getSpeed();
		long time = 0;
		if (speed!=0)
			time = (long)((sharedFile.length() - getTransferredBytes())/speed);
		else
			time = Misc.INFINITY_AS_INT;
		
		return time;
	}
	
	public boolean hasPeer(Peer peer) {
		boolean result =  peer_list.contains(peer);
		if (!result)
			result = connecting_peers.contains(peer);
		return result;
	}
	
	public PeerDownloadStatus getPeerDownloadStatus(Peer peer) {
		return download_status_list.getDownloadStatus(peer);
	}
	
	public JMIterable<Peer> getPeers() {
		List<Peer> list = new LinkedList<Peer>();
		list.addAll(peer_list);
		list.addAll(connecting_peers);
		return new JMIterable<Peer>(list.iterator());
	}
	
	public List<Peer> getPeersAsList() {
		List<Peer> result = new LinkedList<Peer>();
		result.addAll(peer_list);
		result.addAll(connecting_peers);
		return result;
	}
	
	public String toString(){
		
		String str="[ ";
		
		str+= sharedFile.getSharingName() + " " + sharedFile.getGapList() + " " + sharedFile.getFileHash() + "\n";
		str+= "Peer used by session : \n";
		
		for(Peer peer : peer_list)
			str+=peer+"\n";
		
		str+="Connecting peers : \n";
		
		for(Peer peer : connecting_peers) 
			str+=peer+"\n";
		
		str += "\nDownload status list :\n"+ download_status_list + "\n";
		
		str+= fileRequestList+"";
		str+="]";
		
		return str;
	}
	
	public int getStatus() {
		
		return this.sessionStatus;
		
	}
	
	public boolean isStarted() {
		return sessionStatus==STATUS_STARTED;
	}
	
	private void setStatus(int newStatus) {
		
		this.sessionStatus = newStatus;
	}
	
	public int hashCode() {
		
		return this.sharedFile.getFileHash().hashCode();
		
	}
	
	public boolean equals(Object object){
		
		if (object==null) return false;
		
		if (!(object instanceof DownloadSession)) return false;
		
		return this.hashCode()==object.hashCode();
		
	}
	
	public double getPercentCompleted() {
		
		return this.sharedFile.getPercentCompleted();
		
	}
	
	public long getTransferredBytes() {
		
		return this.sharedFile.getDownloadedBytes();
		
	}
	
	public long getFileSize() {
		
		return this.sharedFile.length();
	}
	
	public int getPeersCount() {
		
		return peer_list.size() + connecting_peers.size();
		
	}
	
	public String getTempFileName() {
		
		return sharedFile.getFile().getAbsolutePath();
		
	}
	
	public String getMetFilePath() {
		
		return sharedFile.getPartMetFile().getAbsolutePath();
		
	}
	
	public long getPartCount() {
		
		return Misc.getPartCount(sharedFile.length());
		
	}
	
	public long getAvailablePartCount() {
		
		return sharedFile.getAvailablePartCount();
		
	}
	
	public ED2KFileLink getED2KLink() {
		
		return new ED2KFileLink(getSharingName(),getFileSize(),getFileHash());
		
	}
	
	public SharedFile getSharedFile() {
		
		return sharedFile;
	}	
	
	private void activateUnusedPeers() {
		
		List<PeerDownloadStatus> status_list = download_status_list.getPeersByStatus(PeerDownloadStatus.ACTIVE_UNUSED);
		
		for(PeerDownloadStatus status : status_list) {
			
			fileChunkRequest(status.getPeer());
			
		}
		
	}
	
	
	private void resendFilePartsRequest(Peer peer) {
		
		PeerDownloadStatus status = download_status_list.getDownloadStatus(peer);
		
		if (status.getResendCount()>5) return ;
		
		status.setResendCount(status.getResendCount()+1);
		
		if (status.getLastFilePartRequest()==null) return ;
		
		status.setPeerStatus(status.getPeerStatus());
		
		peer.sendPacket(status.getLastFilePartRequest());
	}

	public int getCompletedSources() {
		return partStatus.getCompletedSources();
	}
	
	public int getPartialSources() {
		return partStatus.getPartialSources();
	}
	
	public int getUnknownSources() {
		return getPeersCount() - (getCompletedSources() + getPartialSources());
	}
	
	/** Query for sources **/
	
	private class SourcesQueryThread extends JMThread {
		
		private boolean stop = false;
		
		public SourcesQueryThread() {
			
			super("Query sources thread");
			
		}
		
		public void run() {
			
			while(!stop) {
				
				queueSources();
				
				try {
					
					this.join(ConfigurationManager.SOURCES_QUERY_INTERVAL);
					
				} catch (InterruptedException e) {
				}
			}
		}
		
		public void JMStop() {
			
			stop = true;
			
			interrupt();
			
		}
		
	}
	
	// disabled, need more research
	private class SlotRequestThread extends JMThread {
		
		private boolean stop = false;
		
		public SlotRequestThread() {
			super("Slot request thread");
		}
		
		public void run() {
			
			while(!stop) {
				
				try {
					Thread.sleep(1000*60*30);
				} catch (InterruptedException e) {
					if (stop) return ;
					continue;
				}
				
				List<PeerDownloadStatus> status_list = download_status_list.getPeersByStatus(PeerDownloadStatus.IN_QUEUE, PeerDownloadStatus.SLOTREQUEST);
				
				for(PeerDownloadStatus status : status_list) {
		
					// test status.getPeer().sendPacket(PacketFactory.getUploadReuqestPacket(sharedFile.getFileHash()));
					
				}
		
			}			
		}
		
		public void JMStop() {
			stop = true;
			interrupt();
			
		}
		
	}
	
	// partial functionality, need more research
	private class PeersMonitor extends JMThread {
		
		private boolean stop = false;
		
		public PeersMonitor() {
			
			super("Download activity monitor");

		}
		
		public void JMStop() {
			
			stop = true;
			
			interrupt();
			
		}
		
		public void run() {
			
			while(!stop) {

				try {
					Thread.sleep(PEER_MONITOR_INTERVAL);
				} catch (InterruptedException e) {
					if (stop) return ;
					continue;
				}
				
				List<PeerDownloadStatus> frenzed_list = download_status_list.getPeersWithInactiveTime(PeerDownloadStatus.ACTIVE,1000*60 * 3);
				
				for(PeerDownloadStatus status : frenzed_list) {
					
					resendFilePartsRequest(status.getPeer());
					
				}
				
				int activePeers = download_status_list.getPeersByStatus(PeerDownloadStatus.ACTIVE_UNUSED).size();
				
				if (activePeers>5) continue;
				
				List<PeerDownloadStatus> status_list = download_status_list.getPeersWithInactiveTime(1000*60*2);
				
				if (activePeers!=0)  {
				
				for(PeerDownloadStatus status : status_list) {
					
					if ( !fileRequestList.hasPeer( status.getPeer() ) ) continue;
					
					if (status.getPeerStatus()!=PeerDownloadStatus.ACTIVE_UNUSED) 
						if (status.getPeerStatus()!=PeerDownloadStatus.IN_QUEUE) {
											
						status.setPeerStatus(PeerDownloadStatus.INACTIVE);
						
						fileRequestList.remove(status.getPeer());
						
					}
					
				}
				
				}
			}
		}
		
	}
}